Upload 22 files

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Case[[:space:]]Study[[:space:]]Constructing[[:space:]]Gradient[[:space:]]Fields/Screenshot[[:space:]]2025-11-20[[:space:]]at[[:space:]]12.49.24 PM.png filter=lfs diff=lfs merge=lfs -text
+Case[[:space:]]Study[[:space:]]Constructing[[:space:]]Gradient[[:space:]]Fields/Screenshot[[:space:]]2025-11-20[[:space:]]at[[:space:]]12.49.37 PM.png filter=lfs diff=lfs merge=lfs -text
+Case[[:space:]]Study[[:space:]]Constructing[[:space:]]Gradient[[:space:]]Fields/Screenshot[[:space:]]2025-11-20[[:space:]]at[[:space:]]12.49.50 PM.png filter=lfs diff=lfs merge=lfs -text
+Case[[:space:]]Study[[:space:]]Constructing[[:space:]]Gradient[[:space:]]Fields/Screenshot[[:space:]]2025-11-20[[:space:]]at[[:space:]]12.50.16 PM.png filter=lfs diff=lfs merge=lfs -text
+output.mp4 filter=lfs diff=lfs merge=lfs -text

Case Study Constructing Gradient Fields/constructing_gradient_fields_case_1_and_2_000.py

@@ -0,0 +1,247 @@
+import sympy as sp
+from abc import ABC, abstractmethod
+from typing import Tuple, Union, Dict
+
+class GradientFieldAnalyzer(ABC):
+    """Abstract base class for analyzing gradient fields"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y', real=True)
+        self.X = sp.Matrix([self.x, self.y])
+    
+    @abstractmethod
+    def find_potential(self) -> sp.Expr:
+        pass
+    
+    @abstractmethod
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        pass
+    
+    def verify_potential(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr) -> bool:
+        """Verify that phi is indeed a potential function for the vector field"""
+        grad_x = sp.diff(phi, self.x) - Vx
+        grad_y = sp.diff(phi, self.y) - Vy
+        
+        return sp.simplify(grad_x) == 0 and sp.simplify(grad_y) == 0
+    
+    def display_results(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr):
+        """Display the results in a formatted way"""
+        print(f"Vector Field: F(x,y) = [{Vx}, {Vy}]")
+        print(f"Potential Function: φ(x,y) = {phi}")
+        print(f"Verification: ∇φ = F? {self.verify_potential(phi, Vx, Vy)}")
+        print("-" * 50)
+
+
+class ConstantComponentField(GradientFieldAnalyzer):
+    """Case 1: One component is constant"""
+    
+    def __init__(self, constant_component: str = 'x', constant_value: sp.Symbol = None):
+        super().__init__()
+        self.constant_component = constant_component.lower()
+        self.c = constant_value if constant_value else sp.Symbol('c', real=True)
+        
+        # Define unknown functions
+        self.F_x = sp.Function('F_x')(self.x)
+        self.F_y = sp.Function('F_y')(self.y)
+    
+    def find_potential(self) -> sp.Expr:
+        if self.constant_component == 'x':
+            # F(x,y) = [c, F_y(y)]
+            Vx = self.c
+            Vy = self.F_y
+            phi = self.c * self.x + sp.Integral(self.F_y, self.y)
+        else:  # constant y-component
+            # F(x,y) = [F_x(x), c]
+            Vx = self.F_x
+            Vy = self.c
+            phi = self.c * self.y + sp.Integral(self.F_x, self.x)
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        if self.constant_component == 'x':
+            return self.c, self.F_y
+        else:
+            return self.F_x, self.c
+    
+    def get_specific_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases with actual functions"""
+        cases = {}
+        
+        # Case 1a: Constant x-component with specific F_y
+        F_y_specific = self.y**2  # Example: F_y(y) = y²
+        Vx1, Vy1 = self.c, F_y_specific
+        phi1 = self.c * self.x + sp.Integral(F_y_specific, self.y).doit()
+        cases['constant_x_component'] = (Vx1, Vy1, phi1)
+        
+        # Case 1b: Constant y-component with specific F_x
+        F_x_specific = sp.sin(self.x)  # Example: F_x(x) = sin(x)
+        Vx2, Vy2 = F_x_specific, self.c
+        phi2 = self.c * self.y + sp.Integral(F_x_specific, self.x).doit()
+        cases['constant_y_component'] = (Vx2, Vy2, phi2)
+        
+        return cases
+
+
+class LinearComponentField(GradientFieldAnalyzer):
+    """Case 2: Both components are linear functions"""
+    
+    def __init__(self):
+        super().__init__()
+        # Define constants for linear functions
+        self.a1, self.b1, self.c1 = sp.symbols('a1 b1 c1', real=True)
+        self.a2, self.b2, self.c2 = sp.symbols('a2 b2 c2', real=True)
+    
+    def find_potential(self, Vx: sp.Expr = None, Vy: sp.Expr = None) -> sp.Expr:
+        """Find potential function for given linear vector field"""
+        if Vx is None or Vy is None:
+            Vx, Vy = self.get_general_linear_field()
+        
+        # Use the method from the case study
+        phi = self._find_potential_2d(Vx, Vy)
+        return phi
+    
+    def _find_potential_2d(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Implementation of find_potential_f2D from the case study"""
+        # Integrate Vx with respect to x
+        phi_x = sp.integrate(Vx, self.x)
+        
+        # Differentiate with respect to y and compare with Vy
+        diff_phi_x_y = sp.diff(phi_x, self.y)
+        remaining = Vy - diff_phi_x_y
+        
+        # Integrate remaining with respect to y
+        phi_y = sp.integrate(remaining, self.y)
+        
+        # Combine results
+        phi = phi_x + phi_y
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        return self.get_general_linear_field()
+    
+    def get_general_linear_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        """General linear vector field: F(x,y) = [a1*x + b1*y + c1, a2*x + b2*y + c2]"""
+        Vx = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy = self.a2 * self.x + self.b2 * self.y + self.c2
+        return Vx, Vy
+    
+    def get_gradient_condition(self) -> sp.Expr:
+        """Return the condition for the field to be a gradient field"""
+        # For a 2D field F = [P, Q] to be a gradient field, we need ∂P/∂y = ∂Q/∂x
+        Vx, Vy = self.get_general_linear_field()
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition)
+    
+    def get_specific_gradient_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases where the field is a gradient field"""
+        cases = {}
+        
+        # Case 2a: a2 = b1 (from the case study)
+        Vx1 = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy1 = self.b1 * self.x + self.b2 * self.y + self.c2  # a2 = b1
+        phi1 = self._find_potential_2d(Vx1, Vy1)
+        cases['symmetric_case_1'] = (Vx1, Vy1, phi1)
+        
+        # Case 2b: b2 = a1 (alternative symmetric case)
+        Vx2 = self.a2 * self.x + self.a1 * self.y + self.c2  # swapped coefficients
+        Vy2 = self.a1 * self.x + self.b1 * self.y + self.c1  # b2 = a1
+        phi2 = self._find_potential_2d(Vx2, Vy2)
+        cases['symmetric_case_2'] = (Vx2, Vy2, phi2)
+        
+        return cases
+
+
+class GradientFieldFactory:
+    """Factory class to create different types of gradient fields"""
+    
+    @staticmethod
+    def create_constant_component_field(component: str = 'x', constant: sp.Symbol = None):
+        return ConstantComponentField(component, constant)
+    
+    @staticmethod
+    def create_linear_component_field():
+        return LinearComponentField()
+    
+    @staticmethod
+    def analyze_all_cases():
+        """Analyze all cases from the case study"""
+        print("=" * 60)
+        print("GRADIENT FIELD CASE STUDY ANALYSIS")
+        print("=" * 60)
+        
+        # Case 1: Constant component
+        print("\nCASE 1: One Component is Constant")
+        print("-" * 40)
+        
+        case1_x = GradientFieldFactory.create_constant_component_field('x')
+        phi1 = case1_x.find_potential()
+        Vx1, Vy1 = case1_x.get_vector_field()
+        case1_x.display_results(phi1, Vx1, Vy1)
+        
+        case1_y = GradientFieldFactory.create_constant_component_field('y')
+        phi2 = case1_y.find_potential()
+        Vx2, Vy2 = case1_y.get_vector_field()
+        case1_y.display_results(phi2, Vx2, Vy2)
+        
+        # Show specific examples
+        print("\nSpecific Examples for Case 1:")
+        examples1 = case1_x.get_specific_cases()
+        for case_name, (Vx, Vy, phi) in examples1.items():
+            print(f"{case_name}:")
+            case1_x.display_results(phi, Vx, Vy)
+        
+        # Case 2: Linear components
+        print("\nCASE 2: Both Components are Linear")
+        print("-" * 40)
+        
+        case2 = GradientFieldFactory.create_linear_component_field()
+        
+        # Show gradient condition
+        condition = case2.get_gradient_condition()
+        print(f"Gradient Field Condition: ∂P/∂y = ∂Q/∂x → {condition} = 0")
+        print(f"This means: a2 = b1 for the general linear field")
+        
+        # Show specific gradient cases
+        print("\nSpecific Gradient Cases for Case 2:")
+        examples2 = case2.get_specific_gradient_cases()
+        for case_name, (Vx, Vy, phi) in examples2.items():
+            print(f"{case_name}:")
+            case2.display_results(phi, Vx, Vy)
+        
+        return case1_x, case1_y, case2
+
+
+# Demonstration and testing
+if __name__ == "__main__":
+    # Run the complete analysis
+    analyzer1, analyzer2, analyzer3 = GradientFieldFactory.analyze_all_cases()
+    
+    # Additional verification with numerical examples
+    print("\n" + "=" * 60)
+    print("NUMERICAL EXAMPLES VERIFICATION")
+    print("=" * 60)
+    
+    # Numerical example for Case 1
+    print("\nNumerical Example - Case 1:")
+    x, y = sp.symbols('x y')
+    c_val = 2
+    
+    # F(x,y) = [2, 3y²]
+    Vx_num1 = c_val
+    Vy_num1 = 3 * y**2
+    phi_num1 = c_val * x + y**3  # ∫3y² dy = y³
+    
+    constant_analyzer = ConstantComponentField('x', sp.symbols('c'))
+    constant_analyzer.display_results(phi_num1, Vx_num1, Vy_num1)
+    
+    # Numerical example for Case 2
+    print("\nNumerical Example - Case 2:")
+    # F(x,y) = [2x + 3y + 1, 3x + 4y + 2] where a2 = b1 = 3
+    Vx_num2 = 2*x + 3*y + 1
+    Vy_num2 = 3*x + 4*y + 2
+    phi_num2 = x**2 + 3*x*y + 2*y**2 + x + 2*y
+    
+    linear_analyzer = LinearComponentField()
+    linear_analyzer.display_results(phi_num2, Vx_num2, Vy_num2)

Case Study Constructing Gradient Fields/constructing_gradient_fields_case_1_and_2_001.py

@@ -0,0 +1,318 @@
+import sympy as sp
+from abc import ABC, abstractmethod
+from typing import Tuple, Union, Dict, List
+
+class GradientFieldAnalyzer(ABC):
+    """Abstract base class for analyzing gradient fields"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y', real=True)
+        self.X = sp.Matrix([self.x, self.y])
+    
+    @abstractmethod
+    def find_potential(self) -> sp.Expr:
+        pass
+    
+    @abstractmethod
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        pass
+    
+    def verify_potential(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr) -> Tuple[bool, sp.Expr, sp.Expr]:
+        """Verify that phi is indeed a potential function for the vector field"""
+        grad_x = sp.diff(phi, self.x)
+        grad_y = sp.diff(phi, self.y)
+        
+        diff_x = sp.simplify(grad_x - Vx)
+        diff_y = sp.simplify(grad_y - Vy)
+        
+        return diff_x == 0 and diff_y == 0, diff_x, diff_y
+    
+    def display_results(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr):
+        """Display the results in a formatted way"""
+        print(f"Vector Field: F(x,y) = [{Vx}, {Vy}]")
+        print(f"Potential Function: φ(x,y) = {phi}")
+        
+        is_valid, diff_x, diff_y = self.verify_potential(phi, Vx, Vy)
+        print(f"Verification: ∇φ = F? {is_valid}")
+        if not is_valid:
+            print(f"  ∂φ/∂x - Vx = {diff_x}")
+            print(f"  ∂φ/∂y - Vy = {diff_y}")
+        print("-" * 50)
+
+
+class ConstantComponentField(GradientFieldAnalyzer):
+    """Case 1: One component is constant"""
+    
+    def __init__(self, constant_component: str = 'x', constant_value: sp.Symbol = None):
+        super().__init__()
+        self.constant_component = constant_component.lower()
+        self.c = constant_value if constant_value else sp.Symbol('c', real=True)
+        
+        # Define unknown functions
+        self.F_x = sp.Function('F_x')(self.x)
+        self.F_y = sp.Function('F_y')(self.y)
+    
+    def find_potential(self) -> sp.Expr:
+        if self.constant_component == 'x':
+            # F(x,y) = [c, F_y(y)]
+            phi = self.c * self.x + sp.Integral(self.F_y, self.y)
+        else:  # constant y-component
+            # F(x,y) = [F_x(x), c]
+            phi = self.c * self.y + sp.Integral(self.F_x, self.x)
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        if self.constant_component == 'x':
+            return self.c, self.F_y
+        else:
+            return self.F_x, self.c
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific vector field (not symbolic)"""
+        if Vx.is_constant():  # Constant x-component
+            phi = Vx * self.x + sp.integrate(Vy, self.y)
+        elif Vy.is_constant():  # Constant y-component
+            phi = Vy * self.y + sp.integrate(Vx, self.x)
+        else:
+            raise ValueError("One component must be constant")
+        return phi
+    
+    def get_specific_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases with actual functions"""
+        cases = {}
+        
+        # Case 1a: Constant x-component with specific F_y
+        F_y_specific = self.y**2  # Example: F_y(y) = y²
+        Vx1, Vy1 = self.c, F_y_specific
+        phi1 = self.find_potential_for_specific_field(self.c, F_y_specific)
+        cases['constant_x_component'] = (Vx1, Vy1, phi1)
+        
+        # Case 1b: Constant y-component with specific F_x
+        F_x_specific = sp.sin(self.x)  # Example: F_x(x) = sin(x)
+        Vx2, Vy2 = F_x_specific, self.c
+        phi2 = self.find_potential_for_specific_field(F_x_specific, self.c)
+        cases['constant_y_component'] = (Vx2, Vy2, phi2)
+        
+        return cases
+
+
+class LinearComponentField(GradientFieldAnalyzer):
+    """Case 2: Both components are linear functions"""
+    
+    def __init__(self):
+        super().__init__()
+        # Define constants for linear functions
+        self.a1, self.b1, self.c1 = sp.symbols('a1 b1 c1', real=True)
+        self.a2, self.b2, self.c2 = sp.symbols('a2 b2 c2', real=True)
+    
+    def find_potential(self, Vx: sp.Expr = None, Vy: sp.Expr = None) -> sp.Expr:
+        """Find potential function for given linear vector field"""
+        if Vx is None or Vy is None:
+            Vx, Vy = self.get_general_linear_field()
+        
+        # Use the method from the case study
+        phi = self._find_potential_2d(Vx, Vy)
+        return phi
+    
+    def _find_potential_2d(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Implementation of find_potential_f2D from the case study"""
+        # Method 1: Integrate Vx with respect to x, then determine y-dependent part
+        phi_x = sp.integrate(Vx, self.x)
+        
+        # The integration constant might be a function of y
+        # Differentiate with respect to y and compare with Vy
+        diff_phi_x_y = sp.diff(phi_x, self.y)
+        remaining = Vy - diff_phi_x_y
+        
+        # Integrate remaining with respect to y
+        phi_y = sp.integrate(remaining, self.y)
+        
+        # Combine results
+        phi = phi_x + phi_y
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        return self.get_general_linear_field()
+    
+    def get_general_linear_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        """General linear vector field: F(x,y) = [a1*x + b1*y + c1, a2*x + b2*y + c2]"""
+        Vx = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy = self.a2 * self.x + self.b2 * self.y + self.c2
+        return Vx, Vy
+    
+    def get_gradient_condition(self) -> sp.Expr:
+        """Return the condition for the field to be a gradient field"""
+        # For a 2D field F = [P, Q] to be a gradient field, we need ∂P/∂y = ∂Q/∂x
+        Vx, Vy = self.get_general_linear_field()
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition)
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific numeric vector field"""
+        return self._find_potential_2d(Vx, Vy)
+    
+    def get_specific_gradient_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases where the field is a gradient field"""
+        cases = {}
+        
+        # Case 2a: a2 = b1 (from the case study)
+        Vx1 = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy1 = self.b1 * self.x + self.b2 * self.y + self.c2  # a2 = b1
+        phi1 = self._find_potential_2d(Vx1, Vy1)
+        cases['symmetric_case_1'] = (Vx1, Vy1, phi1)
+        
+        # Case 2b: b2 = a1 (alternative symmetric case)
+        Vx2 = self.a2 * self.x + self.a1 * self.y + self.c2  # swapped coefficients
+        Vy2 = self.a1 * self.x + self.b1 * self.y + self.c1  # b2 = a1
+        phi2 = self._find_potential_2d(Vx2, Vy2)
+        cases['symmetric_case_2'] = (Vx2, Vy2, phi2)
+        
+        return cases
+
+
+class GradientFieldFactory:
+    """Factory class to create different types of gradient fields"""
+    
+    @staticmethod
+    def create_constant_component_field(component: str = 'x', constant: sp.Symbol = None):
+        return ConstantComponentField(component, constant)
+    
+    @staticmethod
+    def create_linear_component_field():
+        return LinearComponentField()
+    
+    @staticmethod
+    def analyze_all_cases():
+        """Analyze all cases from the case study"""
+        print("=" * 60)
+        print("GRADIENT FIELD CASE STUDY ANALYSIS")
+        print("=" * 60)
+        
+        # Case 1: Constant component
+        print("\nCASE 1: One Component is Constant")
+        print("-" * 40)
+        
+        case1_x = GradientFieldFactory.create_constant_component_field('x')
+        phi1 = case1_x.find_potential()
+        Vx1, Vy1 = case1_x.get_vector_field()
+        case1_x.display_results(phi1, Vx1, Vy1)
+        
+        case1_y = GradientFieldFactory.create_constant_component_field('y')
+        phi2 = case1_y.find_potential()
+        Vx2, Vy2 = case1_y.get_vector_field()
+        case1_y.display_results(phi2, Vx2, Vy2)
+        
+        # Show specific examples
+        print("\nSpecific Examples for Case 1:")
+        examples1 = case1_x.get_specific_cases()
+        for case_name, (Vx, Vy, phi) in examples1.items():
+            print(f"{case_name}:")
+            case1_x.display_results(phi, Vx, Vy)
+        
+        # Case 2: Linear components
+        print("\nCASE 2: Both Components are Linear")
+        print("-" * 40)
+        
+        case2 = GradientFieldFactory.create_linear_component_field()
+        
+        # Show gradient condition
+        condition = case2.get_gradient_condition()
+        print(f"Gradient Field Condition: ∂P/∂y = ∂Q/∂x → {condition} = 0")
+        print(f"This means: a2 = b1 for the general linear field")
+        
+        # Show specific gradient cases
+        print("\nSpecific Gradient Cases for Case 2:")
+        examples2 = case2.get_specific_gradient_cases()
+        for case_name, (Vx, Vy, phi) in examples2.items():
+            print(f"{case_name}:")
+            case2.display_results(phi, Vx, Vy)
+        
+        return case1_x, case1_y, case2
+
+
+class NumericalExamples:
+    """Class to demonstrate and verify numerical examples"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y')
+        self.constant_analyzer = ConstantComponentField()
+        self.linear_analyzer = LinearComponentField()
+    
+    def run_case1_examples(self):
+        """Run numerical examples for Case 1"""
+        print("\nNumerical Examples - Case 1:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2, 3y²]
+        print("Example 1: F(x,y) = [2, 3y²]")
+        Vx1 = 2
+        Vy1 = 3 * self.y**2
+        phi1 = self.constant_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+        self.constant_analyzer.display_results(phi1, Vx1, Vy1)
+        
+        # Example 2: F(x,y) = [sin(x), 5]
+        print("Example 2: F(x,y) = [sin(x), 5]")
+        Vx2 = sp.sin(self.x)
+        Vy2 = 5
+        phi2 = self.constant_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+        self.constant_analyzer.display_results(phi2, Vx2, Vy2)
+    
+    def run_case2_examples(self):
+        """Run numerical examples for Case 2"""
+        print("\nNumerical Examples - Case 2:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2] where a2 = b1 = 3
+        print("Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2]")
+        Vx1 = 2*self.x + 3*self.y + 1
+        Vy1 = 3*self.x + 4*self.y + 2
+        phi1 = self.linear_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+        self.linear_analyzer.display_results(phi1, Vx1, Vy1)
+        
+        # Example 2: F(x,y) = [x + 2y, 2x + 3y] where a2 = b1 = 2
+        print("Example 2: F(x,y) = [x + 2y, 2x + 3y]")
+        Vx2 = self.x + 2*self.y
+        Vy2 = 2*self.x + 3*self.y
+        phi2 = self.linear_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+        self.linear_analyzer.display_results(phi2, Vx2, Vy2)
+        
+        # Example 3: Non-gradient field (should fail verification)
+        print("Example 3: Non-gradient field F(x,y) = [x + y, 2x + y]")
+        Vx3 = self.x + self.y
+        Vy3 = 2*self.x + self.y  # ∂P/∂y = 1, ∂Q/∂x = 2 → not equal
+        try:
+            phi3 = self.linear_analyzer.find_potential_for_specific_field(Vx3, Vy3)
+            self.linear_analyzer.display_results(phi3, Vx3, Vy3)
+        except Exception as e:
+            print(f"Expected error for non-gradient field: {e}")
+            print("This field cannot have a potential function!")
+            print("-" * 50)
+
+
+def main():
+    # Run the complete analysis
+    analyzer1, analyzer2, analyzer3 = GradientFieldFactory.analyze_all_cases()
+    
+    # Run numerical examples
+    print("\n" + "=" * 60)
+    print("NUMERICAL EXAMPLES VERIFICATION")
+    print("=" * 60)
+    
+    numerical_examples = NumericalExamples()
+    numerical_examples.run_case1_examples()
+    numerical_examples.run_case2_examples()
+    
+    # Additional demonstration of the key insight
+    print("\n" + "=" * 60)
+    print("KEY INSIGHT FROM CASE STUDY")
+    print("=" * 60)
+    print("For linear vector fields F(x,y) = [a₁x + b₁y + c₁, a₂x + b₂y + c₂]:")
+    print("• The field is a gradient field IF AND ONLY IF a₂ = b₁")
+    print("• The potential function is: φ(x,y) = ½a₁x² + b₁xy + ½b₂y² + c₁x + c₂y")
+    print("• This matches equations (3.44) and (3.45) from the case study")
+
+
+if __name__ == "__main__":
+    main()

Case Study Constructing Gradient Fields/constructing_gradient_fields_case_1_and_2_002.py

@@ -0,0 +1,326 @@
+import sympy as sp
+from abc import ABC, abstractmethod
+from typing import Tuple, Union, Dict, List
+
+class GradientFieldAnalyzer(ABC):
+    """Abstract base class for analyzing gradient fields"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y', real=True)
+        self.X = sp.Matrix([self.x, self.y])
+    
+    @abstractmethod
+    def find_potential(self) -> sp.Expr:
+        pass
+    
+    @abstractmethod
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        pass
+    
+    def verify_potential(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr) -> Tuple[bool, sp.Expr, sp.Expr]:
+        """Verify that phi is indeed a potential function for the vector field"""
+        grad_x = sp.diff(phi, self.x)
+        grad_y = sp.diff(phi, self.y)
+        
+        diff_x = sp.simplify(grad_x - Vx)
+        diff_y = sp.simplify(grad_y - Vy)
+        
+        return diff_x == 0 and diff_y == 0, diff_x, diff_y
+    
+    def display_results(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr):
+        """Display the results in a formatted way"""
+        print(f"Vector Field: F(x,y) = [{Vx}, {Vy}]")
+        print(f"Potential Function: φ(x,y) = {phi}")
+        
+        is_valid, diff_x, diff_y = self.verify_potential(phi, Vx, Vy)
+        print(f"Verification: ∇φ = F? {is_valid}")
+        if not is_valid:
+            print(f"  ∂φ/∂x - Vx = {diff_x}")
+            print(f"  ∂φ/∂y - Vy = {diff_y}")
+        print("-" * 50)
+
+
+class ConstantComponentField(GradientFieldAnalyzer):
+    """Case 1: One component is constant"""
+    
+    def __init__(self, constant_component: str = 'x', constant_value: sp.Symbol = None):
+        super().__init__()
+        self.constant_component = constant_component.lower()
+        self.c = constant_value if constant_value else sp.Symbol('c', real=True)
+        
+        # Define unknown functions
+        self.F_x = sp.Function('F_x')(self.x)
+        self.F_y = sp.Function('F_y')(self.y)
+    
+    def find_potential(self) -> sp.Expr:
+        if self.constant_component == 'x':
+            # F(x,y) = [c, F_y(y)]
+            phi = self.c * self.x + sp.Integral(self.F_y, self.y)
+        else:  # constant y-component
+            # F(x,y) = [F_x(x), c]
+            phi = self.c * self.y + sp.Integral(self.F_x, self.x)
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        if self.constant_component == 'x':
+            return self.c, self.F_y
+        else:
+            return self.F_x, self.c
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific vector field (not symbolic)"""
+        if Vx.is_constant():  # Constant x-component
+            phi = Vx * self.x + sp.integrate(Vy, self.y)
+        elif Vy.is_constant():  # Constant y-component
+            phi = Vy * self.y + sp.integrate(Vx, self.x)
+        else:
+            raise ValueError("One component must be constant")
+        return phi
+    
+    def get_specific_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases with actual functions"""
+        cases = {}
+        
+        # Case 1a: Constant x-component with specific F_y
+        F_y_specific = self.y**2  # Example: F_y(y) = y²
+        Vx1, Vy1 = self.c, F_y_specific
+        phi1 = self.find_potential_for_specific_field(self.c, F_y_specific)
+        cases['constant_x_component'] = (Vx1, Vy1, phi1)
+        
+        # Case 1b: Constant y-component with specific F_x
+        F_x_specific = sp.sin(self.x)  # Example: F_x(x) = sin(x)
+        Vx2, Vy2 = F_x_specific, self.c
+        phi2 = self.find_potential_for_specific_field(F_x_specific, self.c)
+        cases['constant_y_component'] = (Vx2, Vy2, phi2)
+        
+        return cases
+
+
+class LinearComponentField(GradientFieldAnalyzer):
+    """Case 2: Both components are linear functions"""
+    
+    def __init__(self):
+        super().__init__()
+        # Define constants for linear functions
+        self.a1, self.b1, self.c1 = sp.symbols('a1 b1 c1', real=True)
+        self.a2, self.b2, self.c2 = sp.symbols('a2 b2 c2', real=True)
+    
+    def find_potential(self, Vx: sp.Expr = None, Vy: sp.Expr = None) -> sp.Expr:
+        """Find potential function for given linear vector field"""
+        if Vx is None or Vy is None:
+            Vx, Vy = self.get_general_linear_field()
+        
+        # Use the method from the case study
+        phi = self._find_potential_2d(Vx, Vy)
+        return phi
+    
+    def _find_potential_2d(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Implementation of find_potential_f2D from the case study"""
+        # Method 1: Integrate Vx with respect to x, then determine y-dependent part
+        phi_x = sp.integrate(Vx, self.x)
+        
+        # The integration constant might be a function of y
+        # Differentiate with respect to y and compare with Vy
+        diff_phi_x_y = sp.diff(phi_x, self.y)
+        remaining = Vy - diff_phi_x_y
+        
+        # Integrate remaining with respect to y
+        phi_y = sp.integrate(remaining, self.y)
+        
+        # Combine results
+        phi = phi_x + phi_y
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        return self.get_general_linear_field()
+    
+    def get_general_linear_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        """General linear vector field: F(x,y) = [a1*x + b1*y + c1, a2*x + b2*y + c2]"""
+        Vx = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy = self.a2 * self.x + self.b2 * self.y + self.c2
+        return Vx, Vy
+    
+    def get_gradient_condition(self) -> sp.Expr:
+        """Return the condition for the field to be a gradient field"""
+        # For a 2D field F = [P, Q] to be a gradient field, we need ∂P/∂y = ∂Q/∂x
+        Vx, Vy = self.get_general_linear_field()
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition)
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific numeric vector field"""
+        return self._find_potential_2d(Vx, Vy)
+    
+    def get_specific_gradient_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases where the field is a gradient field"""
+        cases = {}
+        
+        # Case 2a: a2 = b1 (from the case study)
+        Vx1 = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy1 = self.b1 * self.x + self.b2 * self.y + self.c2  # a2 = b1
+        phi1 = self._find_potential_2d(Vx1, Vy1)
+        cases['symmetric_case_1'] = (Vx1, Vy1, phi1)
+        
+        # Case 2b: b2 = a1 (alternative symmetric case)
+        Vx2 = self.a2 * self.x + self.a1 * self.y + self.c2  # swapped coefficients
+        Vy2 = self.a1 * self.x + self.b1 * self.y + self.c1  # b2 = a1
+        phi2 = self._find_potential_2d(Vx2, Vy2)
+        cases['symmetric_case_2'] = (Vx2, Vy2, phi2)
+        
+        return cases
+
+
+class GradientFieldFactory:
+    """Factory class to create different types of gradient fields"""
+    
+    @staticmethod
+    def create_constant_component_field(component: str = 'x', constant: sp.Symbol = None):
+        return ConstantComponentField(component, constant)
+    
+    @staticmethod
+    def create_linear_component_field():
+        return LinearComponentField()
+    
+    @staticmethod
+    def analyze_all_cases():
+        """Analyze all cases from the case study"""
+        print("=" * 60)
+        print("GRADIENT FIELD CASE STUDY ANALYSIS")
+        print("=" * 60)
+        
+        # Case 1: Constant component
+        print("\nCASE 1: One Component is Constant")
+        print("-" * 40)
+        
+        case1_x = GradientFieldFactory.create_constant_component_field('x')
+        phi1 = case1_x.find_potential()
+        Vx1, Vy1 = case1_x.get_vector_field()
+        case1_x.display_results(phi1, Vx1, Vy1)
+        
+        case1_y = GradientFieldFactory.create_constant_component_field('y')
+        phi2 = case1_y.find_potential()
+        Vx2, Vy2 = case1_y.get_vector_field()
+        case1_y.display_results(phi2, Vx2, Vy2)
+        
+        # Show specific examples
+        print("\nSpecific Examples for Case 1:")
+        examples1 = case1_x.get_specific_cases()
+        for case_name, (Vx, Vy, phi) in examples1.items():
+            print(f"{case_name}:")
+            case1_x.display_results(phi, Vx, Vy)
+        
+        # Case 2: Linear components
+        print("\nCASE 2: Both Components are Linear")
+        print("-" * 40)
+        
+        case2 = GradientFieldFactory.create_linear_component_field()
+        
+        # Show gradient condition
+        condition = case2.get_gradient_condition()
+        print(f"Gradient Field Condition: ∂P/∂y = ∂Q/∂x → {condition} = 0")
+        print(f"This means: a2 = b1 for the general linear field")
+        
+        # Show specific gradient cases
+        print("\nSpecific Gradient Cases for Case 2:")
+        examples2 = case2.get_specific_gradient_cases()
+        for case_name, (Vx, Vy, phi) in examples2.items():
+            print(f"{case_name}:")
+            case2.display_results(phi, Vx, Vy)
+        
+        return case1_x, case1_y, case2
+
+
+class NumericalExamples:
+    """Class to demonstrate and verify numerical examples"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y')
+        self.constant_analyzer = ConstantComponentField()
+        self.linear_analyzer = LinearComponentField()
+    
+    def run_case1_examples(self):
+        """Run numerical examples for Case 1"""
+        print("\nNumerical Examples - Case 1:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2, 3y²]
+        print("Example 1: F(x,y) = [2, 3y²]")
+        Vx1 = 2
+        Vy1 = 3 * self.y**2
+        phi1 = self.constant_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+        self.constant_analyzer.display_results(phi1, Vx1, Vy1)
+        
+        # Example 2: F(x,y) = [sin(x), 5]
+        print("Example 2: F(x,y) = [sin(x), 5]")
+        Vx2 = sp.sin(self.x)
+        Vy2 = 5
+        phi2 = self.constant_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+        self.constant_analyzer.display_results(phi2, Vx2, Vy2)
+    
+    def run_case2_examples(self):
+        """Run numerical examples for Case 2"""
+        print("\nNumerical Examples - Case 2:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2] where a2 = b1 = 3
+        print("Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2]")
+        Vx1 = 2*self.x + 3*self.y + 1
+        Vy1 = 3*self.x + 4*self.y + 2
+        phi1 = self.linear_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+        self.linear_analyzer.display_results(phi1, Vx1, Vy1)
+        
+        # Example 2: F(x,y) = [x + 2y, 2x + 3y] where a2 = b1 = 2
+        print("Example 2: F(x,y) = [x + 2y, 2x + 3y]")
+        Vx2 = self.x + 2*self.y
+        Vy2 = 2*self.x + 3*self.y
+        phi2 = self.linear_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+        self.linear_analyzer.display_results(phi2, Vx2, Vy2)
+        
+        # Example 3: Non-gradient field (should fail verification)
+        print("Example 3: Non-gradient field F(x,y) = [x + y, 2x + y]")
+        Vx3 = self.x + self.y
+        Vy3 = 2*self.x + self.y  # ∂P/∂y = 1, ∂Q/∂x = 2 → not equal
+        try:
+            phi3 = self.linear_analyzer.find_potential_for_specific_field(Vx3, Vy3)
+            self.linear_analyzer.display_results(phi3, Vx3, Vy3)
+        except Exception as e:
+            print(f"Expected error for non-gradient field: {e}")
+            print("This field cannot have a potential function!")
+            print("-" * 50)
+
+
+def main():
+    # Run the complete analysis
+    analyzer1, analyzer2, analyzer3 = GradientFieldFactory.analyze_all_cases()
+    
+    # Run numerical examples
+    print("\n" + "=" * 60)
+    print("NUMERICAL EXAMPLES VERIFICATION")
+    print("=" * 60)
+    
+    numerical_examples = NumericalExamples()
+    numerical_examples.run_case1_examples()
+    numerical_examples.run_case2_examples()
+    
+    # Additional demonstration of the key insight
+    print("\n" + "=" * 60)
+    print("KEY INSIGHT FROM CASE STUDY")
+    print("=" * 60)
+    print("For linear vector fields F(x,y) = [a₁x + b₁y + c₁, a₂x + b₂y + c₂]:")
+    print("• The field is a gradient field IF AND ONLY IF a₂ = b₁")
+    print("• The potential function is: φ(x,y) = ½a₁x² + b₁xy + ½b₂y² + c₁x + c₂y")
+    print("• This matches equations (3.44) and (3.45) from the case study")
+    
+    # Show the exact forms from the case study
+    print("\nEXACT FORMS FROM CASE STUDY (Equations 3.44, 3.45):")
+    x, y = sp.symbols('x y')
+    a1, b1, c1, a2, b2, c2 = sp.symbols('a1 b1 c1 a2 b2 c2')
+    
+    print("Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+    print("Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)")
+
+
+if __name__ == "__main__":
+    main()

Case Study Constructing Gradient Fields/constructing_gradient_fields_case_1_and_2_003.py

@@ -0,0 +1,374 @@
+import sympy as sp
+from abc import ABC, abstractmethod
+from typing import Tuple, Union, Dict, List
+
+class GradientFieldAnalyzer(ABC):
+    """Abstract base class for analyzing gradient fields"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y', real=True)
+        self.X = sp.Matrix([self.x, self.y])
+    
+    @abstractmethod
+    def find_potential(self) -> sp.Expr:
+        pass
+    
+    @abstractmethod
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        pass
+    
+    def verify_potential(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr) -> Tuple[bool, sp.Expr, sp.Expr]:
+        """Verify that phi is indeed a potential function for the vector field"""
+        grad_x = sp.diff(phi, self.x)
+        grad_y = sp.diff(phi, self.y)
+        
+        diff_x = sp.simplify(grad_x - Vx)
+        diff_y = sp.simplify(grad_y - Vy)
+        
+        return diff_x == 0 and diff_y == 0, diff_x, diff_y
+    
+    def display_results(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr):
+        """Display the results in a formatted way"""
+        print(f"Vector Field: F(x,y) = [{Vx}, {Vy}]")
+        print(f"Potential Function: φ(x,y) = {phi}")
+        
+        is_valid, diff_x, diff_y = self.verify_potential(phi, Vx, Vy)
+        print(f"Verification: ∇φ = F? {is_valid}")
+        if not is_valid:
+            print(f"  ∂φ/∂x - Vx = {diff_x}")
+            print(f"  ∂φ/∂y - Vy = {diff_y}")
+        print("-" * 50)
+    
+    def _is_constant_expression(self, expr: sp.Expr) -> bool:
+        """Check if an expression is constant (doesn't depend on x or y)"""
+        return len(expr.free_symbols) == 0
+
+
+class ConstantComponentField(GradientFieldAnalyzer):
+    """Case 1: One component is constant"""
+    
+    def __init__(self, constant_component: str = 'x', constant_value: sp.Symbol = None):
+        super().__init__()
+        self.constant_component = constant_component.lower()
+        self.c = constant_value if constant_value else sp.Symbol('c', real=True)
+        
+        # Define unknown functions
+        self.F_x = sp.Function('F_x')(self.x)
+        self.F_y = sp.Function('F_y')(self.y)
+    
+    def find_potential(self) -> sp.Expr:
+        if self.constant_component == 'x':
+            # F(x,y) = [c, F_y(y)]
+            phi = self.c * self.x + sp.Integral(self.F_y, self.y)
+        else:  # constant y-component
+            # F(x,y) = [F_x(x), c]
+            phi = self.c * self.y + sp.Integral(self.F_x, self.x)
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        if self.constant_component == 'x':
+            return self.c, self.F_y
+        else:
+            return self.F_x, self.c
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific vector field (not symbolic)"""
+        # Check which component is constant
+        Vx_free_symbols = Vx.free_symbols if hasattr(Vx, 'free_symbols') else set()
+        Vy_free_symbols = Vy.free_symbols if hasattr(Vy, 'free_symbols') else set()
+        
+        Vx_depends_on_x = self.x in Vx_free_symbols
+        Vx_depends_on_y = self.y in Vx_free_symbols
+        Vy_depends_on_x = self.x in Vy_free_symbols
+        Vy_depends_on_y = self.y in Vy_free_symbols
+        
+        if not Vx_depends_on_x and not Vx_depends_on_y:  # Vx is constant
+            # F(x,y) = [constant, Vy]
+            phi = Vx * self.x + sp.integrate(Vy, self.y)
+        elif not Vy_depends_on_x and not Vy_depends_on_y:  # Vy is constant
+            # F(x,y) = [Vx, constant]
+            phi = Vy * self.y + sp.integrate(Vx, self.x)
+        else:
+            raise ValueError("One component must be constant (independent of both x and y)")
+        return phi
+    
+    def get_specific_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases with actual functions"""
+        cases = {}
+        
+        # Case 1a: Constant x-component with specific F_y
+        F_y_specific = self.y**2  # Example: F_y(y) = y²
+        Vx1 = 2  # Use a numeric constant instead of symbolic c
+        Vy1 = F_y_specific
+        phi1 = self.find_potential_for_specific_field(Vx1, Vy1)
+        cases['constant_x_component'] = (Vx1, Vy1, phi1)
+        
+        # Case 1b: Constant y-component with specific F_x
+        F_x_specific = sp.sin(self.x)  # Example: F_x(x) = sin(x)
+        Vx2 = F_x_specific
+        Vy2 = 3  # Use a numeric constant instead of symbolic c
+        phi2 = self.find_potential_for_specific_field(Vx2, Vy2)
+        cases['constant_y_component'] = (Vx2, Vy2, phi2)
+        
+        return cases
+
+
+class LinearComponentField(GradientFieldAnalyzer):
+    """Case 2: Both components are linear functions"""
+    
+    def __init__(self):
+        super().__init__()
+        # Define constants for linear functions
+        self.a1, self.b1, self.c1 = sp.symbols('a1 b1 c1', real=True)
+        self.a2, self.b2, self.c2 = sp.symbols('a2 b2 c2', real=True)
+    
+    def find_potential(self, Vx: sp.Expr = None, Vy: sp.Expr = None) -> sp.Expr:
+        """Find potential function for given linear vector field"""
+        if Vx is None or Vy is None:
+            Vx, Vy = self.get_general_linear_field()
+        
+        # Use the method from the case study
+        phi = self._find_potential_2d(Vx, Vy)
+        return phi
+    
+    def _find_potential_2d(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Implementation of find_potential_f2D from the case study"""
+        # Method 1: Integrate Vx with respect to x, then determine y-dependent part
+        phi_x = sp.integrate(Vx, self.x)
+        
+        # The integration constant might be a function of y
+        # Differentiate with respect to y and compare with Vy
+        diff_phi_x_y = sp.diff(phi_x, self.y)
+        remaining = Vy - diff_phi_x_y
+        
+        # Integrate remaining with respect to y
+        phi_y = sp.integrate(remaining, self.y)
+        
+        # Combine results
+        phi = phi_x + phi_y
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        return self.get_general_linear_field()
+    
+    def get_general_linear_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        """General linear vector field: F(x,y) = [a1*x + b1*y + c1, a2*x + b2*y + c2]"""
+        Vx = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy = self.a2 * self.x + self.b2 * self.y + self.c2
+        return Vx, Vy
+    
+    def get_gradient_condition(self) -> sp.Expr:
+        """Return the condition for the field to be a gradient field"""
+        # For a 2D field F = [P, Q] to be a gradient field, we need ∂P/∂y = ∂Q/∂x
+        Vx, Vy = self.get_general_linear_field()
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition)
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific numeric vector field"""
+        return self._find_potential_2d(Vx, Vy)
+    
+    def get_specific_gradient_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases where the field is a gradient field"""
+        cases = {}
+        
+        # Case 2a: a2 = b1 (from the case study)
+        Vx1 = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy1 = self.b1 * self.x + self.b2 * self.y + self.c2  # a2 = b1
+        phi1 = self._find_potential_2d(Vx1, Vy1)
+        cases['symmetric_case_1'] = (Vx1, Vy1, phi1)
+        
+        # Case 2b: b2 = a1 (alternative symmetric case)
+        Vx2 = self.a2 * self.x + self.a1 * self.y + self.c2  # swapped coefficients
+        Vy2 = self.a1 * self.x + self.b1 * self.y + self.c1  # b2 = a1
+        phi2 = self._find_potential_2d(Vx2, Vy2)
+        cases['symmetric_case_2'] = (Vx2, Vy2, phi2)
+        
+        return cases
+    
+    def check_gradient_condition_for_specific(self, Vx: sp.Expr, Vy: sp.Expr) -> bool:
+        """Check if a specific vector field satisfies the gradient condition"""
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition) == 0
+
+
+class GradientFieldFactory:
+    """Factory class to create different types of gradient fields"""
+    
+    @staticmethod
+    def create_constant_component_field(component: str = 'x', constant: sp.Symbol = None):
+        return ConstantComponentField(component, constant)
+    
+    @staticmethod
+    def create_linear_component_field():
+        return LinearComponentField()
+    
+    @staticmethod
+    def analyze_all_cases():
+        """Analyze all cases from the case study"""
+        print("=" * 60)
+        print("GRADIENT FIELD CASE STUDY ANALYSIS")
+        print("=" * 60)
+        
+        # Case 1: Constant component
+        print("\nCASE 1: One Component is Constant")
+        print("-" * 40)
+        
+        case1_x = GradientFieldFactory.create_constant_component_field('x')
+        phi1 = case1_x.find_potential()
+        Vx1, Vy1 = case1_x.get_vector_field()
+        case1_x.display_results(phi1, Vx1, Vy1)
+        
+        case1_y = GradientFieldFactory.create_constant_component_field('y')
+        phi2 = case1_y.find_potential()
+        Vx2, Vy2 = case1_y.get_vector_field()
+        case1_y.display_results(phi2, Vx2, Vy2)
+        
+        # Show specific examples
+        print("\nSpecific Examples for Case 1:")
+        examples1 = case1_x.get_specific_cases()
+        for case_name, (Vx, Vy, phi) in examples1.items():
+            print(f"{case_name}:")
+            case1_x.display_results(phi, Vx, Vy)
+        
+        # Case 2: Linear components
+        print("\nCASE 2: Both Components are Linear")
+        print("-" * 40)
+        
+        case2 = GradientFieldFactory.create_linear_component_field()
+        
+        # Show gradient condition
+        condition = case2.get_gradient_condition()
+        print(f"Gradient Field Condition: ∂P/∂y = ∂Q/∂x → {condition} = 0")
+        print(f"This means: a2 = b1 for the general linear field")
+        
+        # Show specific gradient cases
+        print("\nSpecific Gradient Cases for Case 2:")
+        examples2 = case2.get_specific_gradient_cases()
+        for case_name, (Vx, Vy, phi) in examples2.items():
+            print(f"{case_name}:")
+            case2.display_results(phi, Vx, Vy)
+        
+        return case1_x, case1_y, case2
+
+
+class NumericalExamples:
+    """Class to demonstrate and verify numerical examples"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y')
+        self.constant_analyzer = ConstantComponentField()
+        self.linear_analyzer = LinearComponentField()
+    
+    def run_case1_examples(self):
+        """Run numerical examples for Case 1"""
+        print("\nNumerical Examples - Case 1:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2, 3y²]
+        print("Example 1: F(x,y) = [2, 3y²]")
+        Vx1 = 2
+        Vy1 = 3 * self.y**2
+        phi1 = self.constant_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+        self.constant_analyzer.display_results(phi1, Vx1, Vy1)
+        
+        # Example 2: F(x,y) = [sin(x), 5]
+        print("Example 2: F(x,y) = [sin(x), 5]")
+        Vx2 = sp.sin(self.x)
+        Vy2 = 5
+        phi2 = self.constant_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+        self.constant_analyzer.display_results(phi2, Vx2, Vy2)
+    
+    def run_case2_examples(self):
+        """Run numerical examples for Case 2"""
+        print("\nNumerical Examples - Case 2:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2] where a2 = b1 = 3
+        print("Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2]")
+        Vx1 = 2*self.x + 3*self.y + 1
+        Vy1 = 3*self.x + 4*self.y + 2
+        
+        # Check if it's a gradient field first
+        is_gradient = self.linear_analyzer.check_gradient_condition_for_specific(Vx1, Vy1)
+        print(f"Is this a gradient field? {is_gradient}")
+        
+        if is_gradient:
+            phi1 = self.linear_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+            self.linear_analyzer.display_results(phi1, Vx1, Vy1)
+        else:
+            print("This field cannot have a potential function!")
+            print("-" * 50)
+        
+        # Example 2: F(x,y) = [x + 2y, 2x + 3y] where a2 = b1 = 2
+        print("Example 2: F(x,y) = [x + 2y, 2x + 3y]")
+        Vx2 = self.x + 2*self.y
+        Vy2 = 2*self.x + 3*self.y
+        
+        is_gradient2 = self.linear_analyzer.check_gradient_condition_for_specific(Vx2, Vy2)
+        print(f"Is this a gradient field? {is_gradient2}")
+        
+        if is_gradient2:
+            phi2 = self.linear_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+            self.linear_analyzer.display_results(phi2, Vx2, Vy2)
+        else:
+            print("This field cannot have a potential function!")
+            print("-" * 50)
+        
+        # Example 3: Non-gradient field (should fail verification)
+        print("Example 3: Non-gradient field F(x,y) = [x + y, 2x + y]")
+        Vx3 = self.x + self.y
+        Vy3 = 2*self.x + self.y  # ∂P/∂y = 1, ∂Q/∂x = 2 → not equal
+        
+        is_gradient3 = self.linear_analyzer.check_gradient_condition_for_specific(Vx3, Vy3)
+        print(f"Is this a gradient field? {is_gradient3}")
+        
+        if is_gradient3:
+            phi3 = self.linear_analyzer.find_potential_for_specific_field(Vx3, Vy3)
+            self.linear_analyzer.display_results(phi3, Vx3, Vy3)
+        else:
+            print("This field cannot have a potential function!")
+            print("Reason: ∂P/∂y = 1 ≠ ∂Q/∂x = 2")
+            print("-" * 50)
+
+
+def main():
+    # Run the complete analysis
+    analyzer1, analyzer2, analyzer3 = GradientFieldFactory.analyze_all_cases()
+    
+    # Run numerical examples
+    print("\n" + "=" * 60)
+    print("NUMERICAL EXAMPLES VERIFICATION")
+    print("=" * 60)
+    
+    numerical_examples = NumericalExamples()
+    numerical_examples.run_case1_examples()
+    numerical_examples.run_case2_examples()
+    
+    # Additional demonstration of the key insight
+    print("\n" + "=" * 60)
+    print("KEY INSIGHT FROM CASE STUDY")
+    print("=" * 60)
+    print("For linear vector fields F(x,y) = [a₁x + b₁y + c₁, a₂x + b₂y + c₂]:")
+    print("• The field is a gradient field IF AND ONLY IF a₂ = b₁")
+    print("• The potential function is: φ(x,y) = ½a₁x² + b₁xy + ½b₂y² + c₁x + c₂y")
+    print("• This matches equations (3.44) and (3.45) from the case study")
+    
+    # Show the exact forms from the case study
+    print("\nEXACT FORMS FROM CASE STUDY (Equations 3.44, 3.45):")
+    x, y = sp.symbols('x y')
+    a1, b1, c1, a2, b2, c2 = sp.symbols('a1 b1 c1 a2 b2 c2')
+    
+    print("Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+    phi_form1 = a1*x**2/2 + b2*y**2/2 + c2*y + x*(b1*y + c1)
+    print(f"      = {phi_form1}")
+    
+    print("Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)")
+    phi_form2 = a2*x**2/2 + b1*y**2/2 + c1*y + x*(a1*y + c2)
+    print(f"      = {phi_form2}")
+
+
+if __name__ == "__main__":
+    main()

Case Study Constructing Gradient Fields/constructing_gradient_fields_case_1_and_2_004.py

@@ -0,0 +1,405 @@
+import sympy as sp
+from abc import ABC, abstractmethod
+from typing import Tuple, Union, Dict, List
+
+class GradientFieldAnalyzer(ABC):
+    """Abstract base class for analyzing gradient fields"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y', real=True)
+        self.X = sp.Matrix([self.x, self.y])
+    
+    @abstractmethod
+    def find_potential(self) -> sp.Expr:
+        pass
+    
+    @abstractmethod
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        pass
+    
+    def verify_potential(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr) -> Tuple[bool, sp.Expr, sp.Expr]:
+        """Verify that phi is indeed a potential function for the vector field"""
+        grad_x = sp.diff(phi, self.x)
+        grad_y = sp.diff(phi, self.y)
+        
+        diff_x = sp.simplify(grad_x - Vx)
+        diff_y = sp.simplify(grad_y - Vy)
+        
+        return diff_x == 0 and diff_y == 0, diff_x, diff_y
+    
+    def display_results(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr):
+        """Display the results in a formatted way"""
+        print(f"Vector Field: F(x,y) = [{Vx}, {Vy}]")
+        print(f"Potential Function: φ(x,y) = {phi}")
+        
+        is_valid, diff_x, diff_y = self.verify_potential(phi, Vx, Vy)
+        print(f"Verification: ∇φ = F? {is_valid}")
+        if not is_valid:
+            print(f"  ∂φ/∂x - Vx = {diff_x}")
+            print(f"  ∂φ/∂y - Vy = {diff_y}")
+        print("-" * 50)
+    
+    def _is_constant_expression(self, expr: sp.Expr) -> bool:
+        """Check if an expression is constant (doesn't depend on x or y)"""
+        return len(expr.free_symbols) == 0
+
+
+class ConstantComponentField(GradientFieldAnalyzer):
+    """Case 1: One component is constant"""
+    
+    def __init__(self, constant_component: str = 'x', constant_value: sp.Symbol = None):
+        super().__init__()
+        self.constant_component = constant_component.lower()
+        self.c = constant_value if constant_value else sp.Symbol('c', real=True)
+        
+        # Define unknown functions
+        self.F_x = sp.Function('F_x')(self.x)
+        self.F_y = sp.Function('F_y')(self.y)
+    
+    def find_potential(self) -> sp.Expr:
+        if self.constant_component == 'x':
+            # F(x,y) = [c, F_y(y)]
+            phi = self.c * self.x + sp.Integral(self.F_y, self.y)
+        else:  # constant y-component
+            # F(x,y) = [F_x(x), c]
+            phi = self.c * self.y + sp.Integral(self.F_x, self.x)
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        if self.constant_component == 'x':
+            return self.c, self.F_y
+        else:
+            return self.F_x, self.c
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific vector field (not symbolic)"""
+        # Check which component is constant
+        Vx_free_symbols = Vx.free_symbols if hasattr(Vx, 'free_symbols') else set()
+        Vy_free_symbols = Vy.free_symbols if hasattr(Vy, 'free_symbols') else set()
+        
+        Vx_depends_on_x = self.x in Vx_free_symbols
+        Vx_depends_on_y = self.y in Vx_free_symbols
+        Vy_depends_on_x = self.x in Vy_free_symbols
+        Vy_depends_on_y = self.y in Vy_free_symbols
+        
+        if not Vx_depends_on_x and not Vx_depends_on_y:  # Vx is constant
+            # F(x,y) = [constant, Vy]
+            phi = Vx * self.x + sp.integrate(Vy, self.y)
+        elif not Vy_depends_on_x and not Vy_depends_on_y:  # Vy is constant
+            # F(x,y) = [Vx, constant]
+            phi = Vy * self.y + sp.integrate(Vx, self.x)
+        else:
+            raise ValueError("One component must be constant (independent of both x and y)")
+        return phi
+    
+    def get_specific_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases with actual functions"""
+        cases = {}
+        
+        # Case 1a: Constant x-component with specific F_y
+        F_y_specific = self.y**2  # Example: F_y(y) = y²
+        Vx1 = 2  # Use a numeric constant instead of symbolic c
+        Vy1 = F_y_specific
+        phi1 = self.find_potential_for_specific_field(Vx1, Vy1)
+        cases['constant_x_component'] = (Vx1, Vy1, phi1)
+        
+        # Case 1b: Constant y-component with specific F_x
+        F_x_specific = sp.sin(self.x)  # Example: F_x(x) = sin(x)
+        Vx2 = F_x_specific
+        Vy2 = 3  # Use a numeric constant instead of symbolic c
+        phi2 = self.find_potential_for_specific_field(Vx2, Vy2)
+        cases['constant_y_component'] = (Vx2, Vy2, phi2)
+        
+        return cases
+
+
+class LinearComponentField(GradientFieldAnalyzer):
+    """Case 2: Both components are linear functions"""
+    
+    def __init__(self):
+        super().__init__()
+        # Define constants for linear functions
+        self.a1, self.b1, self.c1 = sp.symbols('a1 b1 c1', real=True)
+        self.a2, self.b2, self.c2 = sp.symbols('a2 b2 c2', real=True)
+    
+    def find_potential(self, Vx: sp.Expr = None, Vy: sp.Expr = None) -> sp.Expr:
+        """Find potential function for given linear vector field"""
+        if Vx is None or Vy is None:
+            Vx, Vy = self.get_general_linear_field()
+        
+        # Use the method from the case study
+        phi = self._find_potential_2d(Vx, Vy)
+        return phi
+    
+    def _find_potential_2d(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Implementation of find_potential_f2D from the case study"""
+        # Method: Integrate Vx with respect to x
+        phi_x = sp.integrate(Vx, self.x)
+        
+        # Differentiate with respect to y and compare with Vy
+        diff_phi_x_y = sp.diff(phi_x, self.y)
+        remaining = Vy - diff_phi_x_y
+        
+        # Integrate remaining with respect to y
+        phi_y = sp.integrate(remaining, self.y)
+        
+        # Combine results (no additional constants needed)
+        phi = phi_x + phi_y
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        return self.get_general_linear_field()
+    
+    def get_general_linear_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        """General linear vector field: F(x,y) = [a1*x + b1*y + c1, a2*x + b2*y + c2]"""
+        Vx = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy = self.a2 * self.x + self.b2 * self.y + self.c2
+        return Vx, Vy
+    
+    def get_gradient_condition(self) -> sp.Expr:
+        """Return the condition for the field to be a gradient field"""
+        # For a 2D field F = [P, Q] to be a gradient field, we need ∂P/∂y = ∂Q/∂x
+        Vx, Vy = self.get_general_linear_field()
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition)
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific numeric vector field using correct integration"""
+        # For linear fields, we can use the formula from the case study
+        # First extract coefficients
+        coeffs = self._extract_linear_coefficients(Vx, Vy)
+        
+        if coeffs['a2'] != coeffs['b1']:
+            raise ValueError("Field is not a gradient field - gradient condition not satisfied")
+        
+        # Use the formula: φ(x,y) = ½a₁x² + b₁xy + ½b₂y² + c₁x + c₂y
+        phi = (coeffs['a1'] * self.x**2 / 2 + 
+               coeffs['b1'] * self.x * self.y + 
+               coeffs['b2'] * self.y**2 / 2 + 
+               coeffs['c1'] * self.x + 
+               coeffs['c2'] * self.y)
+        
+        return phi
+    
+    def _extract_linear_coefficients(self, Vx: sp.Expr, Vy: sp.Expr) -> Dict[str, float]:
+        """Extract coefficients from linear vector field components"""
+        # For Vx = a1*x + b1*y + c1
+        a1 = float(sp.diff(Vx, self.x).subs([(self.x, 1), (self.y, 0)])) if self.x in Vx.free_symbols else 0
+        b1 = float(sp.diff(Vx, self.y).subs([(self.x, 0), (self.y, 1)])) if self.y in Vx.free_symbols else 0
+        c1 = float(Vx.subs([(self.x, 0), (self.y, 0)]))
+        
+        # For Vy = a2*x + b2*y + c2  
+        a2 = float(sp.diff(Vy, self.x).subs([(self.x, 1), (self.y, 0)])) if self.x in Vy.free_symbols else 0
+        b2 = float(sp.diff(Vy, self.y).subs([(self.x, 0), (self.y, 1)])) if self.y in Vy.free_symbols else 0
+        c2 = float(Vy.subs([(self.x, 0), (self.y, 0)]))
+        
+        return {'a1': a1, 'b1': b1, 'c1': c1, 'a2': a2, 'b2': b2, 'c2': c2}
+    
+    def get_specific_gradient_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases where the field is a gradient field"""
+        cases = {}
+        
+        # Case 2a: a2 = b1 (from the case study)
+        Vx1 = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy1 = self.b1 * self.x + self.b2 * self.y + self.c2  # a2 = b1
+        phi1 = self._find_potential_2d(Vx1, Vy1)
+        cases['symmetric_case_1'] = (Vx1, Vy1, phi1)
+        
+        # Case 2b: b2 = a1 (alternative symmetric case)
+        Vx2 = self.a2 * self.x + self.a1 * self.y + self.c2  # swapped coefficients
+        Vy2 = self.a1 * self.x + self.b1 * self.y + self.c1  # b2 = a1
+        phi2 = self._find_potential_2d(Vx2, Vy2)
+        cases['symmetric_case_2'] = (Vx2, Vy2, phi2)
+        
+        return cases
+    
+    def check_gradient_condition_for_specific(self, Vx: sp.Expr, Vy: sp.Expr) -> bool:
+        """Check if a specific vector field satisfies the gradient condition"""
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition) == 0
+
+
+class GradientFieldFactory:
+    """Factory class to create different types of gradient fields"""
+    
+    @staticmethod
+    def create_constant_component_field(component: str = 'x', constant: sp.Symbol = None):
+        return ConstantComponentField(component, constant)
+    
+    @staticmethod
+    def create_linear_component_field():
+        return LinearComponentField()
+    
+    @staticmethod
+    def analyze_all_cases():
+        """Analyze all cases from the case study"""
+        print("=" * 60)
+        print("GRADIENT FIELD CASE STUDY ANALYSIS")
+        print("=" * 60)
+        
+        # Case 1: Constant component
+        print("\nCASE 1: One Component is Constant")
+        print("-" * 40)
+        
+        case1_x = GradientFieldFactory.create_constant_component_field('x')
+        phi1 = case1_x.find_potential()
+        Vx1, Vy1 = case1_x.get_vector_field()
+        case1_x.display_results(phi1, Vx1, Vy1)
+        
+        case1_y = GradientFieldFactory.create_constant_component_field('y')
+        phi2 = case1_y.find_potential()
+        Vx2, Vy2 = case1_y.get_vector_field()
+        case1_y.display_results(phi2, Vx2, Vy2)
+        
+        # Show specific examples
+        print("\nSpecific Examples for Case 1:")
+        examples1 = case1_x.get_specific_cases()
+        for case_name, (Vx, Vy, phi) in examples1.items():
+            print(f"{case_name}:")
+            case1_x.display_results(phi, Vx, Vy)
+        
+        # Case 2: Linear components
+        print("\nCASE 2: Both Components are Linear")
+        print("-" * 40)
+        
+        case2 = GradientFieldFactory.create_linear_component_field()
+        
+        # Show gradient condition
+        condition = case2.get_gradient_condition()
+        print(f"Gradient Field Condition: ∂P/∂y = ∂Q/∂x → {condition} = 0")
+        print(f"This means: a2 = b1 for the general linear field")
+        
+        # Show specific gradient cases
+        print("\nSpecific Gradient Cases for Case 2:")
+        examples2 = case2.get_specific_gradient_cases()
+        for case_name, (Vx, Vy, phi) in examples2.items():
+            print(f"{case_name}:")
+            case2.display_results(phi, Vx, Vy)
+        
+        return case1_x, case1_y, case2
+
+
+class NumericalExamples:
+    """Class to demonstrate and verify numerical examples"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y')
+        self.constant_analyzer = ConstantComponentField()
+        self.linear_analyzer = LinearComponentField()
+    
+    def run_case1_examples(self):
+        """Run numerical examples for Case 1"""
+        print("\nNumerical Examples - Case 1:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2, 3y²]
+        print("Example 1: F(x,y) = [2, 3y²]")
+        Vx1 = 2
+        Vy1 = 3 * self.y**2
+        phi1 = self.constant_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+        self.constant_analyzer.display_results(phi1, Vx1, Vy1)
+        
+        # Example 2: F(x,y) = [sin(x), 5]
+        print("Example 2: F(x,y) = [sin(x), 5]")
+        Vx2 = sp.sin(self.x)
+        Vy2 = 5
+        phi2 = self.constant_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+        self.constant_analyzer.display_results(phi2, Vx2, Vy2)
+    
+    def run_case2_examples(self):
+        """Run numerical examples for Case 2"""
+        print("\nNumerical Examples - Case 2:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2] where a2 = b1 = 3
+        print("Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2]")
+        Vx1 = 2*self.x + 3*self.y + 1
+        Vy1 = 3*self.x + 4*self.y + 2
+        
+        # Check if it's a gradient field first
+        is_gradient = self.linear_analyzer.check_gradient_condition_for_specific(Vx1, Vy1)
+        print(f"Is this a gradient field? {is_gradient}")
+        
+        if is_gradient:
+            phi1 = self.linear_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+            self.linear_analyzer.display_results(phi1, Vx1, Vy1)
+        else:
+            print("This field cannot have a potential function!")
+            print("-" * 50)
+        
+        # Example 2: F(x,y) = [x + 2y, 2x + 3y] where a2 = b1 = 2
+        print("Example 2: F(x,y) = [x + 2y, 2x + 3y]")
+        Vx2 = self.x + 2*self.y
+        Vy2 = 2*self.x + 3*self.y
+        
+        is_gradient2 = self.linear_analyzer.check_gradient_condition_for_specific(Vx2, Vy2)
+        print(f"Is this a gradient field? {is_gradient2}")
+        
+        if is_gradient2:
+            phi2 = self.linear_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+            self.linear_analyzer.display_results(phi2, Vx2, Vy2)
+        else:
+            print("This field cannot have a potential function!")
+            print("-" * 50)
+        
+        # Example 3: Non-gradient field (should fail)
+        print("Example 3: Non-gradient field F(x,y) = [x + y, 2x + y]")
+        Vx3 = self.x + self.y
+        Vy3 = 2*self.x + self.y  # ∂P/∂y = 1, ∂Q/∂x = 2 → not equal
+        
+        is_gradient3 = self.linear_analyzer.check_gradient_condition_for_specific(Vx3, Vy3)
+        print(f"Is this a gradient field? {is_gradient3}")
+        
+        if is_gradient3:
+            try:
+                phi3 = self.linear_analyzer.find_potential_for_specific_field(Vx3, Vy3)
+                self.linear_analyzer.display_results(phi3, Vx3, Vy3)
+            except ValueError as e:
+                print(f"Error (expected): {e}")
+                print("This field cannot have a potential function!")
+        else:
+            print("This field cannot have a potential function!")
+            print("Reason: ∂P/∂y = 1 ≠ ∂Q/∂x = 2")
+        print("-" * 50)
+
+
+def main():
+    # Run the complete analysis
+    analyzer1, analyzer2, analyzer3 = GradientFieldFactory.analyze_all_cases()
+    
+    # Run numerical examples
+    print("\n" + "=" * 60)
+    print("NUMERICAL EXAMPLES VERIFICATION")
+    print("=" * 60)
+    
+    numerical_examples = NumericalExamples()
+    numerical_examples.run_case1_examples()
+    numerical_examples.run_case2_examples()
+    
+    # Additional demonstration of the key insight
+    print("\n" + "=" * 60)
+    print("KEY INSIGHT FROM CASE STUDY")
+    print("=" * 60)
+    print("For linear vector fields F(x,y) = [a₁x + b₁y + c₁, a₂x + b₂y + c₂]:")
+    print("• The field is a gradient field IF AND ONLY IF a₂ = b₁")
+    print("• The potential function is: φ(x,y) = ½a₁x² + b₁xy + ½b₂y² + c₁x + c₂y")
+    print("• This matches equations (3.44) and (3.45) from the case study")
+    
+    # Show the exact forms from the case study
+    print("\nEXACT FORMS FROM CASE STUDY (Equations 3.44, 3.45):")
+    x, y = sp.symbols('x y')
+    a1, b1, c1, a2, b2, c2 = sp.symbols('a1 b1 c1 a2 b2 c2')
+    
+    print("Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+    phi_form1 = a1*x**2/2 + b2*y**2/2 + c2*y + x*(b1*y + c1)
+    print(f"      = {phi_form1}")
+    
+    print("Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)")
+    phi_form2 = a2*x**2/2 + b1*y**2/2 + c1*y + x*(a1*y + c2)
+    print(f"      = {phi_form2}")
+
+
+if __name__ == "__main__":
+    main()

Case Study Constructing Gradient Fields/constructing_gradient_fields_case_1_and_2_005.py

@@ -0,0 +1,400 @@
+import sympy as sp
+from abc import ABC, abstractmethod
+from typing import Tuple, Union, Dict, List
+
+class GradientFieldAnalyzer(ABC):
+    """Abstract base class for analyzing gradient fields"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y', real=True)
+        self.X = sp.Matrix([self.x, self.y])
+    
+    @abstractmethod
+    def find_potential(self) -> sp.Expr:
+        pass
+    
+    @abstractmethod
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        pass
+    
+    def verify_potential(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr) -> Tuple[bool, sp.Expr, sp.Expr]:
+        """Verify that phi is indeed a potential function for the vector field"""
+        grad_x = sp.diff(phi, self.x)
+        grad_y = sp.diff(phi, self.y)
+        
+        diff_x = sp.simplify(grad_x - Vx)
+        diff_y = sp.simplify(grad_y - Vy)
+        
+        return diff_x == 0 and diff_y == 0, diff_x, diff_y
+    
+    def display_results(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr):
+        """Display the results in a formatted way"""
+        print(f"Vector Field: F(x,y) = [{Vx}, {Vy}]")
+        print(f"Potential Function: φ(x,y) = {phi}")
+        
+        is_valid, diff_x, diff_y = self.verify_potential(phi, Vx, Vy)
+        print(f"Verification: ∇φ = F? {is_valid}")
+        if not is_valid:
+            print(f"  ∂φ/∂x - Vx = {diff_x}")
+            print(f"  ∂φ/∂y - Vy = {diff_y}")
+        print("-" * 50)
+
+
+class ConstantComponentField(GradientFieldAnalyzer):
+    """Case 1: One component is constant"""
+    
+    def __init__(self, constant_component: str = 'x', constant_value: sp.Symbol = None):
+        super().__init__()
+        self.constant_component = constant_component.lower()
+        self.c = constant_value if constant_value else sp.Symbol('c', real=True)
+        
+        # Define unknown functions
+        self.F_x = sp.Function('F_x')(self.x)
+        self.F_y = sp.Function('F_y')(self.y)
+    
+    def find_potential(self) -> sp.Expr:
+        if self.constant_component == 'x':
+            # F(x,y) = [c, F_y(y)]
+            phi = self.c * self.x + sp.Integral(self.F_y, self.y)
+        else:  # constant y-component
+            # F(x,y) = [F_x(x), c]
+            phi = self.c * self.y + sp.Integral(self.F_x, self.x)
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        if self.constant_component == 'x':
+            return self.c, self.F_y
+        else:
+            return self.F_x, self.c
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific vector field (not symbolic)"""
+        # Check which component is constant
+        Vx_free_symbols = Vx.free_symbols if hasattr(Vx, 'free_symbols') else set()
+        Vy_free_symbols = Vy.free_symbols if hasattr(Vy, 'free_symbols') else set()
+        
+        Vx_depends_on_x = self.x in Vx_free_symbols
+        Vx_depends_on_y = self.y in Vx_free_symbols
+        Vy_depends_on_x = self.x in Vy_free_symbols
+        Vy_depends_on_y = self.y in Vy_free_symbols
+        
+        if not Vx_depends_on_x and not Vx_depends_on_y:  # Vx is constant
+            # F(x,y) = [constant, Vy]
+            phi = Vx * self.x + sp.integrate(Vy, self.y)
+        elif not Vy_depends_on_x and not Vy_depends_on_y:  # Vy is constant
+            # F(x,y) = [Vx, constant]
+            phi = Vy * self.y + sp.integrate(Vx, self.x)
+        else:
+            raise ValueError("One component must be constant (independent of both x and y)")
+        return phi
+    
+    def get_specific_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases with actual functions"""
+        cases = {}
+        
+        # Case 1a: Constant x-component with specific F_y
+        F_y_specific = self.y**2  # Example: F_y(y) = y²
+        Vx1 = 2  # Use a numeric constant instead of symbolic c
+        Vy1 = F_y_specific
+        phi1 = self.find_potential_for_specific_field(Vx1, Vy1)
+        cases['constant_x_component'] = (Vx1, Vy1, phi1)
+        
+        # Case 1b: Constant y-component with specific F_x
+        F_x_specific = sp.sin(self.x)  # Example: F_x(x) = sin(x)
+        Vx2 = F_x_specific
+        Vy2 = 3  # Use a numeric constant instead of symbolic c
+        phi2 = self.find_potential_for_specific_field(Vx2, Vy2)
+        cases['constant_y_component'] = (Vx2, Vy2, phi2)
+        
+        return cases
+
+
+class LinearComponentField(GradientFieldAnalyzer):
+    """Case 2: Both components are linear functions"""
+    
+    def __init__(self):
+        super().__init__()
+        # Define constants for linear functions
+        self.a1, self.b1, self.c1 = sp.symbols('a1 b1 c1', real=True)
+        self.a2, self.b2, self.c2 = sp.symbols('a2 b2 c2', real=True)
+    
+    def find_potential(self, Vx: sp.Expr = None, Vy: sp.Expr = None) -> sp.Expr:
+        """Find potential function for given linear vector field"""
+        if Vx is None or Vy is None:
+            Vx, Vy = self.get_general_linear_field()
+        
+        # Use the method from the case study
+        phi = self._find_potential_2d(Vx, Vy)
+        return phi
+    
+    def _find_potential_2d(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Implementation of find_potential_f2D from the case study"""
+        # Method: Integrate Vx with respect to x
+        phi_x = sp.integrate(Vx, self.x)
+        
+        # Differentiate with respect to y and compare with Vy
+        diff_phi_x_y = sp.diff(phi_x, self.y)
+        remaining = Vy - diff_phi_x_y
+        
+        # Integrate remaining with respect to y
+        phi_y = sp.integrate(remaining, self.y)
+        
+        # Combine results (no additional constants needed)
+        phi = phi_x + phi_y
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        return self.get_general_linear_field()
+    
+    def get_general_linear_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        """General linear vector field: F(x,y) = [a1*x + b1*y + c1, a2*x + b2*y + c2]"""
+        Vx = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy = self.a2 * self.x + self.b2 * self.y + self.c2
+        return Vx, Vy
+    
+    def get_gradient_condition(self) -> sp.Expr:
+        """Return the condition for the field to be a gradient field"""
+        # For a 2D field F = [P, Q] to be a gradient field, we need ∂P/∂y = ∂Q/∂x
+        Vx, Vy = self.get_general_linear_field()
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition)
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific numeric vector field using correct integration"""
+        # Use the direct integration method that works for any gradient field
+        return self._find_potential_2d(Vx, Vy)
+    
+    def get_specific_gradient_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases where the field is a gradient field"""
+        cases = {}
+        
+        # Case 2a: a2 = b1 (from the case study) - FORM 1
+        Vx1 = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy1 = self.b1 * self.x + self.b2 * self.y + self.c2  # a2 = b1
+        phi1 = self._find_potential_2d(Vx1, Vy1)
+        cases['symmetric_case_1'] = (Vx1, Vy1, phi1)
+        
+        # Case 2b: b2 = a1 (alternative symmetric case) - FORM 2  
+        Vx2 = self.a2 * self.x + self.a1 * self.y + self.c2  # swapped coefficients
+        Vy2 = self.a1 * self.x + self.b1 * self.y + self.c1  # b2 = a1
+        phi2 = self._find_potential_2d(Vx2, Vy2)
+        cases['symmetric_case_2'] = (Vx2, Vy2, phi2)
+        
+        return cases
+    
+    def check_gradient_condition_for_specific(self, Vx: sp.Expr, Vy: sp.Expr) -> bool:
+        """Check if a specific vector field satisfies the gradient condition"""
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition) == 0
+    
+    def demonstrate_case_study_forms(self):
+        """Demonstrate the exact forms from the case study"""
+        print("\nEXACT FORMS FROM CASE STUDY:")
+        print("=" * 50)
+        
+        # Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)
+        print("Form 1 (Equation 3.44):")
+        phi_form1 = self.a1 * self.x**2 / 2 + self.b2 * self.y**2 / 2 + self.c2 * self.y + self.x * (self.b1 * self.y + self.c1)
+        print(f"φ(x,y) = {phi_form1}")
+        
+        Vx_form1 = sp.diff(phi_form1, self.x)
+        Vy_form1 = sp.diff(phi_form1, self.y)
+        print(f"F(x,y) = ∇φ = [{Vx_form1}, {Vy_form1}]")
+        print(f"Matches Form 1 from case study: {Vx_form1 == self.a1*self.x + self.b1*self.y + self.c1 and Vy_form1 == self.b1*self.x + self.b2*self.y + self.c2}")
+        print()
+        
+        # Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)
+        print("Form 2 (Equation 3.44):")
+        phi_form2 = self.a2 * self.x**2 / 2 + self.b1 * self.y**2 / 2 + self.c1 * self.y + self.x * (self.a1 * self.y + self.c2)
+        print(f"φ(x,y) = {phi_form2}")
+        
+        Vx_form2 = sp.diff(phi_form2, self.x)
+        Vy_form2 = sp.diff(phi_form2, self.y)
+        print(f"F(x,y) = ∇φ = [{Vx_form2}, {Vy_form2}]")
+        print(f"Matches Form 2 from case study: {Vx_form2 == self.a2*self.x + self.a1*self.y + self.c2 and Vy_form2 == self.a1*self.x + self.b1*self.y + self.c1}")
+        print()
+
+
+class GradientFieldFactory:
+    """Factory class to create different types of gradient fields"""
+    
+    @staticmethod
+    def create_constant_component_field(component: str = 'x', constant: sp.Symbol = None):
+        return ConstantComponentField(component, constant)
+    
+    @staticmethod
+    def create_linear_component_field():
+        return LinearComponentField()
+    
+    @staticmethod
+    def analyze_all_cases():
+        """Analyze all cases from the case study"""
+        print("=" * 60)
+        print("GRADIENT FIELD CASE STUDY ANALYSIS")
+        print("=" * 60)
+        
+        # Case 1: Constant component
+        print("\nCASE 1: One Component is Constant")
+        print("-" * 40)
+        
+        case1_x = GradientFieldFactory.create_constant_component_field('x')
+        phi1 = case1_x.find_potential()
+        Vx1, Vy1 = case1_x.get_vector_field()
+        case1_x.display_results(phi1, Vx1, Vy1)
+        
+        case1_y = GradientFieldFactory.create_constant_component_field('y')
+        phi2 = case1_y.find_potential()
+        Vx2, Vy2 = case1_y.get_vector_field()
+        case1_y.display_results(phi2, Vx2, Vy2)
+        
+        # Show specific examples
+        print("\nSpecific Examples for Case 1:")
+        examples1 = case1_x.get_specific_cases()
+        for case_name, (Vx, Vy, phi) in examples1.items():
+            print(f"{case_name}:")
+            case1_x.display_results(phi, Vx, Vy)
+        
+        # Case 2: Linear components
+        print("\nCASE 2: Both Components are Linear")
+        print("-" * 40)
+        
+        case2 = GradientFieldFactory.create_linear_component_field()
+        
+        # Show gradient condition
+        condition = case2.get_gradient_condition()
+        print(f"Gradient Field Condition: ∂P/∂y = ∂Q/∂x → {condition} = 0")
+        print(f"This means: a2 = b1 for the general linear field")
+        
+        # Show specific gradient cases
+        print("\nSpecific Gradient Cases for Case 2:")
+        examples2 = case2.get_specific_gradient_cases()
+        for case_name, (Vx, Vy, phi) in examples2.items():
+            print(f"{case_name}:")
+            case2.display_results(phi, Vx, Vy)
+        
+        # Demonstrate the exact forms from the case study
+        case2.demonstrate_case_study_forms()
+        
+        return case1_x, case1_y, case2
+
+
+class NumericalExamples:
+    """Class to demonstrate and verify numerical examples"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y')
+        self.constant_analyzer = ConstantComponentField()
+        self.linear_analyzer = LinearComponentField()
+    
+    def run_case1_examples(self):
+        """Run numerical examples for Case 1"""
+        print("\nNumerical Examples - Case 1:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2, 3y²]
+        print("Example 1: F(x,y) = [2, 3y²]")
+        Vx1 = 2
+        Vy1 = 3 * self.y**2
+        phi1 = self.constant_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+        self.constant_analyzer.display_results(phi1, Vx1, Vy1)
+        
+        # Example 2: F(x,y) = [sin(x), 5]
+        print("Example 2: F(x,y) = [sin(x), 5]")
+        Vx2 = sp.sin(self.x)
+        Vy2 = 5
+        phi2 = self.constant_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+        self.constant_analyzer.display_results(phi2, Vx2, Vy2)
+    
+    def run_case2_examples(self):
+        """Run numerical examples for Case 2"""
+        print("\nNumerical Examples - Case 2:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2] where a2 = b1 = 3
+        print("Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2]")
+        Vx1 = 2*self.x + 3*self.y + 1
+        Vy1 = 3*self.x + 4*self.y + 2
+        
+        # Check if it's a gradient field first
+        is_gradient = self.linear_analyzer.check_gradient_condition_for_specific(Vx1, Vy1)
+        print(f"Is this a gradient field? {is_gradient}")
+        
+        if is_gradient:
+            phi1 = self.linear_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+            self.linear_analyzer.display_results(phi1, Vx1, Vy1)
+            
+            # Show that this matches Form 1 from the case study
+            print("This matches Form 1 from case study with:")
+            print("  a1 = 2, b1 = 3, c1 = 1")
+            print("  a2 = 3, b2 = 4, c2 = 2")
+            print("  φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+            print(f"        = 2x²/2 + 4y²/2 + 2y + x(3y + 1)")
+            print(f"        = {phi1}")
+        else:
+            print("This field cannot have a potential function!")
+        print("-" * 50)
+        
+        # Example 2: F(x,y) = [x + 2y, 2x + 3y] where a2 = b1 = 2
+        print("Example 2: F(x,y) = [x + 2y, 2x + 3y]")
+        Vx2 = self.x + 2*self.y
+        Vy2 = 2*self.x + 3*self.y
+        
+        is_gradient2 = self.linear_analyzer.check_gradient_condition_for_specific(Vx2, Vy2)
+        print(f"Is this a gradient field? {is_gradient2}")
+        
+        if is_gradient2:
+            phi2 = self.linear_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+            self.linear_analyzer.display_results(phi2, Vx2, Vy2)
+        else:
+            print("This field cannot have a potential function!")
+        print("-" * 50)
+        
+        # Example 3: Non-gradient field (should fail)
+        print("Example 3: Non-gradient field F(x,y) = [x + y, 2x + y]")
+        Vx3 = self.x + self.y
+        Vy3 = 2*self.x + self.y  # ∂P/∂y = 1, ∂Q/∂x = 2 → not equal
+        
+        is_gradient3 = self.linear_analyzer.check_gradient_condition_for_specific(Vx3, Vy3)
+        print(f"Is this a gradient field? {is_gradient3}")
+        
+        if is_gradient3:
+            try:
+                phi3 = self.linear_analyzer.find_potential_for_specific_field(Vx3, Vy3)
+                self.linear_analyzer.display_results(phi3, Vx3, Vy3)
+            except Exception as e:
+                print(f"Error finding potential: {e}")
+        else:
+            print("This field cannot have a potential function!")
+            print("Reason: ∂P/∂y = 1 ≠ ∂Q/∂x = 2")
+        print("-" * 50)
+
+
+def main():
+    # Run the complete analysis
+    analyzer1, analyzer2, analyzer3 = GradientFieldFactory.analyze_all_cases()
+    
+    # Run numerical examples
+    print("\n" + "=" * 60)
+    print("NUMERICAL EXAMPLES VERIFICATION")
+    print("=" * 60)
+    
+    numerical_examples = NumericalExamples()
+    numerical_examples.run_case1_examples()
+    numerical_examples.run_case2_examples()
+    
+    # Additional demonstration of the key insight
+    print("\n" + "=" * 60)
+    print("KEY INSIGHT FROM CASE STUDY")
+    print("=" * 60)
+    print("For linear vector fields F(x,y) = [a₁x + b₁y + c₁, a₂x + b₂y + c₂]:")
+    print("• The field is a gradient field IF AND ONLY IF a₂ = b₁")
+    print("• The potential function has two equivalent forms:")
+    print("  Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+    print("  Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)")
+    print("• These match equations (3.44) and (3.45) from the case study")
+
+
+if __name__ == "__main__":
+    main()

Case Study Constructing Gradient Fields/constructing_gradient_fields_case_1_and_2_006.py

@@ -0,0 +1,412 @@
+import sympy as sp
+from abc import ABC, abstractmethod
+from typing import Tuple, Union, Dict, List
+
+class GradientFieldAnalyzer(ABC):
+    """Abstract base class for analyzing gradient fields"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y', real=True)
+        self.X = sp.Matrix([self.x, self.y])
+    
+    @abstractmethod
+    def find_potential(self) -> sp.Expr:
+        pass
+    
+    @abstractmethod
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        pass
+    
+    def verify_potential(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr) -> Tuple[bool, sp.Expr, sp.Expr]:
+        """Verify that phi is indeed a potential function for the vector field"""
+        grad_x = sp.diff(phi, self.x)
+        grad_y = sp.diff(phi, self.y)
+        
+        diff_x = sp.simplify(grad_x - Vx)
+        diff_y = sp.simplify(grad_y - Vy)
+        
+        return diff_x == 0 and diff_y == 0, diff_x, diff_y
+    
+    def display_results(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr):
+        """Display the results in a formatted way"""
+        print(f"Vector Field: F(x,y) = [{Vx}, {Vy}]")
+        print(f"Potential Function: φ(x,y) = {sp.simplify(phi)}")
+        
+        is_valid, diff_x, diff_y = self.verify_potential(phi, Vx, Vy)
+        print(f"Verification: ∇φ = F? {is_valid}")
+        if not is_valid:
+            print(f"  ∂φ/∂x - Vx = {diff_x}")
+            print(f"  ∂φ/∂y - Vy = {diff_y}")
+        print("-" * 50)
+
+
+class ConstantComponentField(GradientFieldAnalyzer):
+    """Case 1: One component is constant"""
+    
+    def __init__(self, constant_component: str = 'x', constant_value: sp.Symbol = None):
+        super().__init__()
+        self.constant_component = constant_component.lower()
+        self.c = constant_value if constant_value else sp.Symbol('c', real=True)
+        
+        # Define unknown functions
+        self.F_x = sp.Function('F_x')(self.x)
+        self.F_y = sp.Function('F_y')(self.y)
+    
+    def find_potential(self) -> sp.Expr:
+        if self.constant_component == 'x':
+            # F(x,y) = [c, F_y(y)]
+            phi = self.c * self.x + sp.Integral(self.F_y, self.y)
+        else:  # constant y-component
+            # F(x,y) = [F_x(x), c]
+            phi = self.c * self.y + sp.Integral(self.F_x, self.x)
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        if self.constant_component == 'x':
+            return self.c, self.F_y
+        else:
+            return self.F_x, self.c
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific vector field (not symbolic)"""
+        # Check which component is constant
+        Vx_free_symbols = Vx.free_symbols if hasattr(Vx, 'free_symbols') else set()
+        Vy_free_symbols = Vy.free_symbols if hasattr(Vy, 'free_symbols') else set()
+        
+        Vx_depends_on_x = self.x in Vx_free_symbols
+        Vx_depends_on_y = self.y in Vx_free_symbols
+        Vy_depends_on_x = self.x in Vy_free_symbols
+        Vy_depends_on_y = self.y in Vy_free_symbols
+        
+        if not Vx_depends_on_x and not Vx_depends_on_y:  # Vx is constant
+            # F(x,y) = [constant, Vy]
+            phi = Vx * self.x + sp.integrate(Vy, self.y)
+        elif not Vy_depends_on_x and not Vy_depends_on_y:  # Vy is constant
+            # F(x,y) = [Vx, constant]
+            phi = Vy * self.y + sp.integrate(Vx, self.x)
+        else:
+            raise ValueError("One component must be constant (independent of both x and y)")
+        return sp.simplify(phi)
+    
+    def get_specific_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases with actual functions"""
+        cases = {}
+        
+        # Case 1a: Constant x-component with specific F_y
+        F_y_specific = self.y**2  # Example: F_y(y) = y²
+        Vx1 = 2  # Use a numeric constant instead of symbolic c
+        Vy1 = F_y_specific
+        phi1 = self.find_potential_for_specific_field(Vx1, Vy1)
+        cases['constant_x_component'] = (Vx1, Vy1, phi1)
+        
+        # Case 1b: Constant y-component with specific F_x
+        F_x_specific = sp.sin(self.x)  # Example: F_x(x) = sin(x)
+        Vx2 = F_x_specific
+        Vy2 = 3  # Use a numeric constant instead of symbolic c
+        phi2 = self.find_potential_for_specific_field(Vx2, Vy2)
+        cases['constant_y_component'] = (Vx2, Vy2, phi2)
+        
+        return cases
+
+
+class LinearComponentField(GradientFieldAnalyzer):
+    """Case 2: Both components are linear functions"""
+    
+    def __init__(self):
+        super().__init__()
+        # Define constants for linear functions
+        self.a1, self.b1, self.c1 = sp.symbols('a1 b1 c1', real=True)
+        self.a2, self.b2, self.c2 = sp.symbols('a2 b2 c2', real=True)
+    
+    def find_potential(self, Vx: sp.Expr = None, Vy: sp.Expr = None) -> sp.Expr:
+        """Find potential function for given linear vector field"""
+        if Vx is None or Vy is None:
+            Vx, Vy = self.get_general_linear_field()
+        
+        # Use the method from the case study
+        phi = self._find_potential_2d(Vx, Vy)
+        return phi
+    
+    def _find_potential_2d(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Implementation of find_potential_f2D from the case study"""
+        # Method: Integrate Vx with respect to x
+        phi_x = sp.integrate(Vx, self.x)
+        
+        # Differentiate with respect to y and compare with Vy
+        diff_phi_x_y = sp.diff(phi_x, self.y)
+        remaining = Vy - diff_phi_x_y
+        
+        # Integrate remaining with respect to y
+        phi_y = sp.integrate(remaining, self.y)
+        
+        # Combine results (no additional constants needed)
+        phi = phi_x + phi_y
+        
+        return sp.simplify(phi)
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        return self.get_general_linear_field()
+    
+    def get_general_linear_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        """General linear vector field: F(x,y) = [a1*x + b1*y + c1, a2*x + b2*y + c2]"""
+        Vx = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy = self.a2 * self.x + self.b2 * self.y + self.c2
+        return Vx, Vy
+    
+    def get_gradient_condition(self) -> sp.Expr:
+        """Return the condition for the field to be a gradient field"""
+        # For a 2D field F = [P, Q] to be a gradient field, we need ∂P/∂y = ∂Q/∂x
+        Vx, Vy = self.get_general_linear_field()
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition)
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific numeric vector field using correct integration"""
+        # Use the direct integration method that works for any gradient field
+        return self._find_potential_2d(Vx, Vy)
+    
+    def get_specific_gradient_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases where the field is a gradient field"""
+        cases = {}
+        
+        # Case 2a: a2 = b1 (from the case study) - FORM 1
+        Vx1 = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy1 = self.b1 * self.x + self.b2 * self.y + self.c2  # a2 = b1
+        phi1 = self._find_potential_2d(Vx1, Vy1)
+        cases['symmetric_case_1'] = (Vx1, Vy1, phi1)
+        
+        # Case 2b: b2 = a1 (alternative symmetric case) - FORM 2  
+        Vx2 = self.a2 * self.x + self.a1 * self.y + self.c2  # swapped coefficients
+        Vy2 = self.a1 * self.x + self.b1 * self.y + self.c1  # b2 = a1
+        phi2 = self._find_potential_2d(Vx2, Vy2)
+        cases['symmetric_case_2'] = (Vx2, Vy2, phi2)
+        
+        return cases
+    
+    def check_gradient_condition_for_specific(self, Vx: sp.Expr, Vy: sp.Expr) -> bool:
+        """Check if a specific vector field satisfies the gradient condition"""
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition) == 0
+    
+    def demonstrate_case_study_forms(self):
+        """Demonstrate the exact forms from the case study"""
+        print("\nEXACT FORMS FROM CASE STUDY:")
+        print("=" * 50)
+        
+        # Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)
+        print("Form 1 (Equation 3.44):")
+        phi_form1 = self.a1 * self.x**2 / 2 + self.b2 * self.y**2 / 2 + self.c2 * self.y + self.x * (self.b1 * self.y + self.c1)
+        print(f"φ(x,y) = {phi_form1}")
+        
+        Vx_form1 = sp.diff(phi_form1, self.x)
+        Vy_form1 = sp.diff(phi_form1, self.y)
+        print(f"F(x,y) = ∇φ = [{Vx_form1}, {Vy_form1}]")
+        print(f"Matches Form 1 from case study: {Vx_form1 == self.a1*self.x + self.b1*self.y + self.c1 and Vy_form1 == self.b1*self.x + self.b2*self.y + self.c2}")
+        print()
+        
+        # Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)
+        print("Form 2 (Equation 3.44):")
+        phi_form2 = self.a2 * self.x**2 / 2 + self.b1 * self.y**2 / 2 + self.c1 * self.y + self.x * (self.a1 * self.y + self.c2)
+        print(f"φ(x,y) = {phi_form2}")
+        
+        Vx_form2 = sp.diff(phi_form2, self.x)
+        Vy_form2 = sp.diff(phi_form2, self.y)
+        print(f"F(x,y) = ∇φ = [{Vx_form2}, {Vy_form2}]")
+        print(f"Matches Form 2 from case study: {Vx_form2 == self.a2*self.x + self.a1*self.y + self.c2 and Vy_form2 == self.a1*self.x + self.b1*self.y + self.c1}")
+        print()
+
+
+class GradientFieldFactory:
+    """Factory class to create different types of gradient fields"""
+    
+    @staticmethod
+    def create_constant_component_field(component: str = 'x', constant: sp.Symbol = None):
+        return ConstantComponentField(component, constant)
+    
+    @staticmethod
+    def create_linear_component_field():
+        return LinearComponentField()
+    
+    @staticmethod
+    def analyze_all_cases():
+        """Analyze all cases from the case study"""
+        print("=" * 60)
+        print("GRADIENT FIELD CASE STUDY ANALYSIS")
+        print("=" * 60)
+        
+        # Case 1: Constant component
+        print("\nCASE 1: One Component is Constant")
+        print("-" * 40)
+        
+        case1_x = GradientFieldFactory.create_constant_component_field('x')
+        phi1 = case1_x.find_potential()
+        Vx1, Vy1 = case1_x.get_vector_field()
+        case1_x.display_results(phi1, Vx1, Vy1)
+        
+        case1_y = GradientFieldFactory.create_constant_component_field('y')
+        phi2 = case1_y.find_potential()
+        Vx2, Vy2 = case1_y.get_vector_field()
+        case1_y.display_results(phi2, Vx2, Vy2)
+        
+        # Show specific examples
+        print("\nSpecific Examples for Case 1:")
+        examples1 = case1_x.get_specific_cases()
+        for case_name, (Vx, Vy, phi) in examples1.items():
+            print(f"{case_name}:")
+            case1_x.display_results(phi, Vx, Vy)
+        
+        # Case 2: Linear components
+        print("\nCASE 2: Both Components are Linear")
+        print("-" * 40)
+        
+        case2 = GradientFieldFactory.create_linear_component_field()
+        
+        # Show gradient condition
+        condition = case2.get_gradient_condition()
+        print(f"Gradient Field Condition: ∂P/∂y = ∂Q/∂x → {condition} = 0")
+        print(f"This means: a2 = b1 for the general linear field")
+        
+        # Show specific gradient cases
+        print("\nSpecific Gradient Cases for Case 2:")
+        examples2 = case2.get_specific_gradient_cases()
+        for case_name, (Vx, Vy, phi) in examples2.items():
+            print(f"{case_name}:")
+            case2.display_results(phi, Vx, Vy)
+        
+        # Demonstrate the exact forms from the case study
+        case2.demonstrate_case_study_forms()
+        
+        return case1_x, case1_y, case2
+
+
+class NumericalExamples:
+    """Class to demonstrate and verify numerical examples"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y')
+        self.constant_analyzer = ConstantComponentField()
+        self.linear_analyzer = LinearComponentField()
+    
+    def run_case1_examples(self):
+        """Run numerical examples for Case 1"""
+        print("\nNumerical Examples - Case 1:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2, 3y²]
+        print("Example 1: F(x,y) = [2, 3y²]")
+        Vx1 = 2
+        Vy1 = 3 * self.y**2
+        phi1 = self.constant_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+        self.constant_analyzer.display_results(phi1, Vx1, Vy1)
+        
+        # Example 2: F(x,y) = [sin(x), 5]
+        print("Example 2: F(x,y) = [sin(x), 5]")
+        Vx2 = sp.sin(self.x)
+        Vy2 = 5
+        phi2 = self.constant_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+        self.constant_analyzer.display_results(phi2, Vx2, Vy2)
+    
+    def run_case2_examples(self):
+        """Run numerical examples for Case 2"""
+        print("\nNumerical Examples - Case 2:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2] where a2 = b1 = 3
+        print("Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2]")
+        Vx1 = 2*self.x + 3*self.y + 1
+        Vy1 = 3*self.x + 4*self.y + 2
+        
+        # Check if it's a gradient field first
+        is_gradient = self.linear_analyzer.check_gradient_condition_for_specific(Vx1, Vy1)
+        print(f"Is this a gradient field? {is_gradient}")
+        
+        if is_gradient:
+            phi1 = self.linear_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+            self.linear_analyzer.display_results(phi1, Vx1, Vy1)
+            
+            # Show that this matches Form 1 from the case study
+            print("This matches Form 1 from case study with:")
+            print("  a1 = 2, b1 = 3, c1 = 1")
+            print("  a2 = 3, b2 = 4, c2 = 2")
+            phi_form1 = 2*self.x**2/2 + 4*self.y**2/2 + 2*self.y + self.x*(3*self.y + 1)
+            print(f"  φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+            print(f"        = {sp.simplify(phi_form1)}")
+        else:
+            print("This field cannot have a potential function!")
+        print("-" * 50)
+        
+        # Example 2: F(x,y) = [x + 2y, 2x + 3y] where a2 = b1 = 2
+        print("Example 2: F(x,y) = [x + 2y, 2x + 3y]")
+        Vx2 = self.x + 2*self.y
+        Vy2 = 2*self.x + 3*self.y
+        
+        is_gradient2 = self.linear_analyzer.check_gradient_condition_for_specific(Vx2, Vy2)
+        print(f"Is this a gradient field? {is_gradient2}")
+        
+        if is_gradient2:
+            phi2 = self.linear_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+            self.linear_analyzer.display_results(phi2, Vx2, Vy2)
+        else:
+            print("This field cannot have a potential function!")
+        print("-" * 50)
+        
+        # Example 3: Non-gradient field (should fail)
+        print("Example 3: Non-gradient field F(x,y) = [x + y, 2x + y]")
+        Vx3 = self.x + self.y
+        Vy3 = 2*self.x + self.y
+        
+        is_gradient3 = self.linear_analyzer.check_gradient_condition_for_specific(Vx3, Vy3)
+        print(f"Is this a gradient field? {is_gradient3}")
+        
+        if is_gradient3:
+            print("ERROR: This should not be a gradient field!")
+            print("Let's check the gradient condition:")
+            print(f"  ∂P/∂y = {sp.diff(Vx3, self.y)}")
+            print(f"  ∂Q/∂x = {sp.diff(Vy3, self.x)}")
+            print(f"  Gradient condition satisfied? {sp.diff(Vx3, self.y) == sp.diff(Vy3, self.x)}")
+            
+            # Even if the method finds something, it shouldn't verify
+            try:
+                phi3 = self.linear_analyzer.find_potential_for_specific_field(Vx3, Vy3)
+                self.linear_analyzer.display_results(phi3, Vx3, Vy3)
+            except Exception as e:
+                print(f"Error finding potential: {e}")
+        else:
+            print("✓ Correct: This field cannot have a potential function!")
+            print(f"Reason: ∂P/∂y = {sp.diff(Vx3, self.y)} ≠ ∂Q/∂x = {sp.diff(Vy3, self.x)}")
+            print("The gradient condition a₂ = b₁ is not satisfied")
+        print("-" * 50)
+
+
+def main():
+    # Run the complete analysis
+    analyzer1, analyzer2, analyzer3 = GradientFieldFactory.analyze_all_cases()
+    
+    # Run numerical examples
+    print("\n" + "=" * 60)
+    print("NUMERICAL EXAMPLES VERIFICATION")
+    print("=" * 60)
+    
+    numerical_examples = NumericalExamples()
+    numerical_examples.run_case1_examples()
+    numerical_examples.run_case2_examples()
+    
+    # Additional demonstration of the key insight
+    print("\n" + "=" * 60)
+    print("KEY INSIGHT FROM CASE STUDY")
+    print("=" * 60)
+    print("For linear vector fields F(x,y) = [a₁x + b₁y + c₁, a₂x + b₂y + c₂]:")
+    print("• The field is a gradient field IF AND ONLY IF a₂ = b₁")
+    print("• The potential function has two equivalent forms:")
+    print("  Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+    print("  Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)")
+    print("• These match equations (3.44) from the case study")
+    print("\nSUMMARY OF RESULTS:")
+    print("• Case 1 (constant component): Always a gradient field")
+    print("• Case 2 (linear components): Gradient field only when a₂ = b₁")
+    print("• The integration method correctly identifies gradient fields")
+
+
+if __name__ == "__main__":
+    main()

Case Study Constructing Gradient Fields/constructing_gradient_fields_case_1_and_2_007.py

@@ -0,0 +1,421 @@
+import sympy as sp
+from abc import ABC, abstractmethod
+from typing import Tuple, Union, Dict, List
+
+class GradientFieldAnalyzer(ABC):
+    """Abstract base class for analyzing gradient fields"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y', real=True)
+        self.X = sp.Matrix([self.x, self.y])
+    
+    @abstractmethod
+    def find_potential(self) -> sp.Expr:
+        pass
+    
+    @abstractmethod
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        pass
+    
+    def verify_potential(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr) -> Tuple[bool, sp.Expr, sp.Expr]:
+        """Verify that phi is indeed a potential function for the vector field"""
+        grad_x = sp.diff(phi, self.x)
+        grad_y = sp.diff(phi, self.y)
+        
+        diff_x = sp.simplify(grad_x - Vx)
+        diff_y = sp.simplify(grad_y - Vy)
+        
+        return diff_x == 0 and diff_y == 0, diff_x, diff_y
+    
+    def display_results(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr):
+        """Display the results in a formatted way"""
+        print(f"Vector Field: F(x,y) = [{Vx}, {Vy}]")
+        print(f"Potential Function: φ(x,y) = {sp.simplify(phi)}")
+        
+        is_valid, diff_x, diff_y = self.verify_potential(phi, Vx, Vy)
+        print(f"Verification: ∇φ = F? {is_valid}")
+        if not is_valid:
+            print(f"  ∂φ/∂x - Vx = {diff_x}")
+            print(f"  ∂φ/∂y - Vy = {diff_y}")
+        print("-" * 50)
+
+
+class ConstantComponentField(GradientFieldAnalyzer):
+    """Case 1: One component is constant"""
+    
+    def __init__(self, constant_component: str = 'x', constant_value: sp.Symbol = None):
+        super().__init__()
+        self.constant_component = constant_component.lower()
+        self.c = constant_value if constant_value else sp.Symbol('c', real=True)
+        
+        # Define unknown functions
+        self.F_x = sp.Function('F_x')(self.x)
+        self.F_y = sp.Function('F_y')(self.y)
+    
+    def find_potential(self) -> sp.Expr:
+        if self.constant_component == 'x':
+            # F(x,y) = [c, F_y(y)]
+            phi = self.c * self.x + sp.Integral(self.F_y, self.y)
+        else:  # constant y-component
+            # F(x,y) = [F_x(x), c]
+            phi = self.c * self.y + sp.Integral(self.F_x, self.x)
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        if self.constant_component == 'x':
+            return self.c, self.F_y
+        else:
+            return self.F_x, self.c
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific vector field (not symbolic)"""
+        # Check which component is constant
+        Vx_free_symbols = Vx.free_symbols if hasattr(Vx, 'free_symbols') else set()
+        Vy_free_symbols = Vy.free_symbols if hasattr(Vy, 'free_symbols') else set()
+        
+        Vx_depends_on_x = self.x in Vx_free_symbols
+        Vx_depends_on_y = self.y in Vx_free_symbols
+        Vy_depends_on_x = self.x in Vy_free_symbols
+        Vy_depends_on_y = self.y in Vy_free_symbols
+        
+        if not Vx_depends_on_x and not Vx_depends_on_y:  # Vx is constant
+            # F(x,y) = [constant, Vy]
+            phi = Vx * self.x + sp.integrate(Vy, self.y)
+        elif not Vy_depends_on_x and not Vy_depends_on_y:  # Vy is constant
+            # F(x,y) = [Vx, constant]
+            phi = Vy * self.y + sp.integrate(Vx, self.x)
+        else:
+            raise ValueError("One component must be constant (independent of both x and y)")
+        return sp.simplify(phi)
+    
+    def get_specific_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases with actual functions"""
+        cases = {}
+        
+        # Case 1a: Constant x-component with specific F_y
+        F_y_specific = self.y**2  # Example: F_y(y) = y²
+        Vx1 = 2  # Use a numeric constant instead of symbolic c
+        Vy1 = F_y_specific
+        phi1 = self.find_potential_for_specific_field(Vx1, Vy1)
+        cases['constant_x_component'] = (Vx1, Vy1, phi1)
+        
+        # Case 1b: Constant y-component with specific F_x
+        F_x_specific = sp.sin(self.x)  # Example: F_x(x) = sin(x)
+        Vx2 = F_x_specific
+        Vy2 = 3  # Use a numeric constant instead of symbolic c
+        phi2 = self.find_potential_for_specific_field(Vx2, Vy2)
+        cases['constant_y_component'] = (Vx2, Vy2, phi2)
+        
+        return cases
+
+
+class LinearComponentField(GradientFieldAnalyzer):
+    """Case 2: Both components are linear functions"""
+    
+    def __init__(self):
+        super().__init__()
+        # Define constants for linear functions
+        self.a1, self.b1, self.c1 = sp.symbols('a1 b1 c1', real=True)
+        self.a2, self.b2, self.c2 = sp.symbols('a2 b2 c2', real=True)
+    
+    def find_potential(self, Vx: sp.Expr = None, Vy: sp.Expr = None) -> sp.Expr:
+        """Find potential function for given linear vector field"""
+        if Vx is None or Vy is None:
+            Vx, Vy = self.get_general_linear_field()
+        
+        # Use the method from the case study
+        phi = self._find_potential_2d(Vx, Vy)
+        return phi
+    
+    def _find_potential_2d(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Implementation of find_potential_f2D from the case study"""
+        # First check if it's a gradient field
+        if not self.check_gradient_condition_for_specific(Vx, Vy):
+            raise ValueError("Field is not a gradient field - cannot find potential")
+        
+        # Method: Integrate Vx with respect to x
+        phi_x = sp.integrate(Vx, self.x)
+        
+        # Differentiate with respect to y and compare with Vy
+        diff_phi_x_y = sp.diff(phi_x, self.y)
+        remaining = Vy - diff_phi_x_y
+        
+        # Integrate remaining with respect to y
+        phi_y = sp.integrate(remaining, self.y)
+        
+        # Combine results (no additional constants needed)
+        phi = phi_x + phi_y
+        
+        return sp.simplify(phi)
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        return self.get_general_linear_field()
+    
+    def get_general_linear_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        """General linear vector field: F(x,y) = [a1*x + b1*y + c1, a2*x + b2*y + c2]"""
+        Vx = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy = self.a2 * self.x + self.b2 * self.y + self.c2
+        return Vx, Vy
+    
+    def get_gradient_condition(self) -> sp.Expr:
+        """Return the condition for the field to be a gradient field"""
+        # For a 2D field F = [P, Q] to be a gradient field, we need ∂P/∂y = ∂Q/∂x
+        Vx, Vy = self.get_general_linear_field()
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition)
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific numeric vector field using correct integration"""
+        # Use the direct integration method that works for any gradient field
+        return self._find_potential_2d(Vx, Vy)
+    
+    def get_specific_gradient_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases where the field is a gradient field"""
+        cases = {}
+        
+        # Case 2a: a2 = b1 (from the case study) - FORM 1
+        Vx1 = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy1 = self.b1 * self.x + self.b2 * self.y + self.c2  # a2 = b1
+        phi1 = self._find_potential_2d(Vx1, Vy1)
+        cases['symmetric_case_1'] = (Vx1, Vy1, phi1)
+        
+        # Case 2b: b2 = a1 (alternative symmetric case) - FORM 2  
+        Vx2 = self.a2 * self.x + self.a1 * self.y + self.c2  # swapped coefficients
+        Vy2 = self.a1 * self.x + self.b1 * self.y + self.c1  # b2 = a1
+        phi2 = self._find_potential_2d(Vx2, Vy2)
+        cases['symmetric_case_2'] = (Vx2, Vy2, phi2)
+        
+        return cases
+    
+    def check_gradient_condition_for_specific(self, Vx: sp.Expr, Vy: sp.Expr) -> bool:
+        """Check if a specific vector field satisfies the gradient condition"""
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition) == 0
+    
+    def demonstrate_case_study_forms(self):
+        """Demonstrate the exact forms from the case study"""
+        print("\nEXACT FORMS FROM CASE STUDY:")
+        print("=" * 50)
+        
+        # Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)
+        print("Form 1 (Equation 3.44):")
+        phi_form1 = self.a1 * self.x**2 / 2 + self.b2 * self.y**2 / 2 + self.c2 * self.y + self.x * (self.b1 * self.y + self.c1)
+        print(f"φ(x,y) = {phi_form1}")
+        
+        Vx_form1 = sp.diff(phi_form1, self.x)
+        Vy_form1 = sp.diff(phi_form1, self.y)
+        print(f"F(x,y) = ∇φ = [{Vx_form1}, {Vy_form1}]")
+        print(f"Matches Form 1 from case study: {Vx_form1 == self.a1*self.x + self.b1*self.y + self.c1 and Vy_form1 == self.b1*self.x + self.b2*self.y + self.c2}")
+        print()
+        
+        # Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)
+        print("Form 2 (Equation 3.44):")
+        phi_form2 = self.a2 * self.x**2 / 2 + self.b1 * self.y**2 / 2 + self.c1 * self.y + self.x * (self.a1 * self.y + self.c2)
+        print(f"φ(x,y) = {phi_form2}")
+        
+        Vx_form2 = sp.diff(phi_form2, self.x)
+        Vy_form2 = sp.diff(phi_form2, self.y)
+        print(f"F(x,y) = ∇φ = [{Vx_form2}, {Vy_form2}]")
+        print(f"Matches Form 2 from case study: {Vx_form2 == self.a2*self.x + self.a1*self.y + self.c2 and Vy_form2 == self.a1*self.x + self.b1*self.y + self.c1}")
+        print()
+
+
+class GradientFieldFactory:
+    """Factory class to create different types of gradient fields"""
+    
+    @staticmethod
+    def create_constant_component_field(component: str = 'x', constant: sp.Symbol = None):
+        return ConstantComponentField(component, constant)
+    
+    @staticmethod
+    def create_linear_component_field():
+        return LinearComponentField()
+    
+    @staticmethod
+    def analyze_all_cases():
+        """Analyze all cases from the case study"""
+        print("=" * 60)
+        print("GRADIENT FIELD CASE STUDY ANALYSIS")
+        print("=" * 60)
+        
+        # Case 1: Constant component
+        print("\nCASE 1: One Component is Constant")
+        print("-" * 40)
+        
+        case1_x = GradientFieldFactory.create_constant_component_field('x')
+        phi1 = case1_x.find_potential()
+        Vx1, Vy1 = case1_x.get_vector_field()
+        case1_x.display_results(phi1, Vx1, Vy1)
+        
+        case1_y = GradientFieldFactory.create_constant_component_field('y')
+        phi2 = case1_y.find_potential()
+        Vx2, Vy2 = case1_y.get_vector_field()
+        case1_y.display_results(phi2, Vx2, Vy2)
+        
+        # Show specific examples
+        print("\nSpecific Examples for Case 1:")
+        examples1 = case1_x.get_specific_cases()
+        for case_name, (Vx, Vy, phi) in examples1.items():
+            print(f"{case_name}:")
+            case1_x.display_results(phi, Vx, Vy)
+        
+        # Case 2: Linear components
+        print("\nCASE 2: Both Components are Linear")
+        print("-" * 40)
+        
+        case2 = GradientFieldFactory.create_linear_component_field()
+        
+        # Show gradient condition
+        condition = case2.get_gradient_condition()
+        print(f"Gradient Field Condition: ∂P/∂y = ∂Q/∂x → {condition} = 0")
+        print(f"This means: a2 = b1 for the general linear field")
+        
+        # Show specific gradient cases
+        print("\nSpecific Gradient Cases for Case 2:")
+        examples2 = case2.get_specific_gradient_cases()
+        for case_name, (Vx, Vy, phi) in examples2.items():
+            print(f"{case_name}:")
+            case2.display_results(phi, Vx, Vy)
+        
+        # Demonstrate the exact forms from the case study
+        case2.demonstrate_case_study_forms()
+        
+        return case1_x, case1_y, case2
+
+
+class NumericalExamples:
+    """Class to demonstrate and verify numerical examples"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y')
+        self.constant_analyzer = ConstantComponentField()
+        self.linear_analyzer = LinearComponentField()
+    
+    def run_case1_examples(self):
+        """Run numerical examples for Case 1"""
+        print("\nNumerical Examples - Case 1:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2, 3y²]
+        print("Example 1: F(x,y) = [2, 3y²]")
+        Vx1 = 2
+        Vy1 = 3 * self.y**2
+        phi1 = self.constant_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+        self.constant_analyzer.display_results(phi1, Vx1, Vy1)
+        
+        # Example 2: F(x,y) = [sin(x), 5]
+        print("Example 2: F(x,y) = [sin(x), 5]")
+        Vx2 = sp.sin(self.x)
+        Vy2 = 5
+        phi2 = self.constant_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+        self.constant_analyzer.display_results(phi2, Vx2, Vy2)
+    
+    def run_case2_examples(self):
+        """Run numerical examples for Case 2"""
+        print("\nNumerical Examples - Case 2:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2] where a2 = b1 = 3
+        print("Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2]")
+        Vx1 = 2*self.x + 3*self.y + 1
+        Vy1 = 3*self.x + 4*self.y + 2
+        
+        # Check if it's a gradient field first
+        is_gradient = self.linear_analyzer.check_gradient_condition_for_specific(Vx1, Vy1)
+        print(f"Is this a gradient field? {is_gradient}")
+        
+        if is_gradient:
+            phi1 = self.linear_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+            self.linear_analyzer.display_results(phi1, Vx1, Vy1)
+            
+            # Show that this matches Form 1 from the case study
+            print("This matches Form 1 from case study with:")
+            print("  a1 = 2, b1 = 3, c1 = 1")
+            print("  a2 = 3, b2 = 4, c2 = 2")
+            phi_form1 = 2*self.x**2/2 + 4*self.y**2/2 + 2*self.y + self.x*(3*self.y + 1)
+            print(f"  φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+            print(f"        = {sp.simplify(phi_form1)}")
+        else:
+            print("This field cannot have a potential function!")
+        print("-" * 50)
+        
+        # Example 2: F(x,y) = [x + 2y, 2x + 3y] where a2 = b1 = 2
+        print("Example 2: F(x,y) = [x + 2y, 2x + 3y]")
+        Vx2 = self.x + 2*self.y
+        Vy2 = 2*self.x + 3*self.y
+        
+        is_gradient2 = self.linear_analyzer.check_gradient_condition_for_specific(Vx2, Vy2)
+        print(f"Is this a gradient field? {is_gradient2}")
+        
+        if is_gradient2:
+            phi2 = self.linear_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+            self.linear_analyzer.display_results(phi2, Vx2, Vy2)
+        else:
+            print("This field cannot have a potential function!")
+        print("-" * 50)
+        
+        # Example 3: Non-gradient field (should fail)
+        print("Example 3: Non-gradient field F(x,y) = [x + y, 2x + y]")
+        Vx3 = self.x + self.y
+        Vy3 = 2*self.x + self.y
+        
+        is_gradient3 = self.linear_analyzer.check_gradient_condition_for_specific(Vx3, Vy3)
+        print(f"Is this a gradient field? {is_gradient3}")
+        
+        if is_gradient3:
+            print("ERROR: This should not be a gradient field!")
+            print("Let's check the gradient condition:")
+            print(f"  ∂P/∂y = {sp.diff(Vx3, self.y)}")
+            print(f"  ∂Q/∂x = {sp.diff(Vy3, self.x)}")
+            print(f"  Gradient condition satisfied? {sp.diff(Vx3, self.y) == sp.diff(Vy3, self.x)}")
+            
+            # Even if the method finds something, it shouldn't verify
+            try:
+                phi3 = self.linear_analyzer.find_potential_for_specific_field(Vx3, Vy3)
+                is_valid, diff_x, diff_y = self.linear_analyzer.verify_potential(phi3, Vx3, Vy3)
+                print(f"Attempted potential: φ(x,y) = {phi3}")
+                print(f"Verification: ∇φ = F? {is_valid}")
+                if not is_valid:
+                    print(f"  ∂φ/∂x - Vx = {diff_x}")
+                    print(f"  ∂φ/∂y - Vy = {diff_y}")
+            except ValueError as e:
+                print(f"✓ Correct: {e}")
+        else:
+            print("✓ Correct: This field cannot have a potential function!")
+            print(f"Reason: ∂P/∂y = {sp.diff(Vx3, self.y)} ≠ ∂Q/∂x = {sp.diff(Vy3, self.x)}")
+            print("The gradient condition a₂ = b₁ is not satisfied")
+        print("-" * 50)
+
+
+def main():
+    # Run the complete analysis
+    analyzer1, analyzer2, analyzer3 = GradientFieldFactory.analyze_all_cases()
+    
+    # Run numerical examples
+    print("\n" + "=" * 60)
+    print("NUMERICAL EXAMPLES VERIFICATION")
+    print("=" * 60)
+    
+    numerical_examples = NumericalExamples()
+    numerical_examples.run_case1_examples()
+    numerical_examples.run_case2_examples()
+    
+    # Additional demonstration of the key insight
+    print("\n" + "=" * 60)
+    print("KEY INSIGHT FROM CASE STUDY")
+    print("=" * 60)
+    print("For linear vector fields F(x,y) = [a₁x + b₁y + c₁, a₂x + b₂y + c₂]:")
+    print("• The field is a gradient field IF AND ONLY IF a₂ = b₁")
+    print("• The potential function has two equivalent forms:")
+    print("  Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+    print("  Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)")
+    print("• These match equations (3.44) from the case study")
+    print("\nSUMMARY OF RESULTS:")
+    print("• Case 1 (constant component): Always a gradient field")
+    print("• Case 2 (linear components): Gradient field only when a₂ = b₁")
+    print("• The integration method correctly identifies gradient fields")
+
+
+if __name__ == "__main__":
+    main()

Case Study Constructing Gradient Fields/constructing_gradient_fields_case_1_and_2_008.py

@@ -0,0 +1,451 @@
+import sympy as sp
+from abc import ABC, abstractmethod
+from typing import Tuple, Union, Dict, List
+
+class GradientFieldAnalyzer(ABC):
+    """Abstract base class for analyzing gradient fields"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y', real=True)
+        self.X = sp.Matrix([self.x, self.y])
+    
+    @abstractmethod
+    def find_potential(self) -> sp.Expr:
+        pass
+    
+    @abstractmethod
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        pass
+    
+    def verify_potential(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr) -> Tuple[bool, sp.Expr, sp.Expr]:
+        """Verify that phi is indeed a potential function for the vector field"""
+        grad_x = sp.diff(phi, self.x)
+        grad_y = sp.diff(phi, self.y)
+        
+        # Use equals() method for robust comparison instead of ==
+        diff_x = sp.simplify(grad_x - Vx)
+        diff_y = sp.simplify(grad_y - Vy)
+        
+        is_valid = diff_x.equals(0) and diff_y.equals(0)
+        return is_valid, diff_x, diff_y
+    
+    def display_results(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr):
+        """Display the results in a formatted way"""
+        print(f"Vector Field: F(x,y) = [{Vx}, {Vy}]")
+        print(f"Potential Function: φ(x,y) = {sp.simplify(phi)}")
+        
+        is_valid, diff_x, diff_y = self.verify_potential(phi, Vx, Vy)
+        print(f"Verification: ∇φ = F? {is_valid}")
+        if not is_valid:
+            print(f"  ∂φ/∂x - Vx = {diff_x}")
+            print(f"  ∂φ/∂y - Vy = {diff_y}")
+        print("-" * 50)
+
+
+class ConstantComponentField(GradientFieldAnalyzer):
+    """Case 1: One component is constant"""
+    
+    def __init__(self, constant_component: str = 'x', constant_value: sp.Symbol = None):
+        super().__init__()
+        self.constant_component = constant_component.lower()
+        self.c = constant_value if constant_value else sp.Symbol('c', real=True)
+        
+        # Define unknown functions
+        self.F_x = sp.Function('F_x')(self.x)
+        self.F_y = sp.Function('F_y')(self.y)
+    
+    def find_potential(self) -> sp.Expr:
+        if self.constant_component == 'x':
+            # F(x,y) = [c, F_y(y)]
+            phi = self.c * self.x + sp.Integral(self.F_y, self.y)
+        else:  # constant y-component
+            # F(x,y) = [F_x(x), c]
+            phi = self.c * self.y + sp.Integral(self.F_x, self.x)
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        if self.constant_component == 'x':
+            return self.c, self.F_y
+        else:
+            return self.F_x, self.c
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific vector field (not symbolic)"""
+        # Check which component is constant
+        Vx_free_symbols = Vx.free_symbols if hasattr(Vx, 'free_symbols') else set()
+        Vy_free_symbols = Vy.free_symbols if hasattr(Vy, 'free_symbols') else set()
+        
+        Vx_depends_on_x = self.x in Vx_free_symbols
+        Vx_depends_on_y = self.y in Vx_free_symbols
+        Vy_depends_on_x = self.x in Vy_free_symbols
+        Vy_depends_on_y = self.y in Vy_free_symbols
+        
+        if not Vx_depends_on_x and not Vx_depends_on_y:  # Vx is constant
+            # F(x,y) = [constant, Vy]
+            phi = Vx * self.x + sp.integrate(Vy, self.y)
+        elif not Vy_depends_on_x and not Vy_depends_on_y:  # Vy is constant
+            # F(x,y) = [Vx, constant]
+            phi = Vy * self.y + sp.integrate(Vx, self.x)
+        else:
+            raise ValueError("One component must be constant (independent of both x and y)")
+        return sp.simplify(phi)
+    
+    def get_specific_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases with actual functions"""
+        cases = {}
+        
+        # Case 1a: Constant x-component with specific F_y
+        F_y_specific = self.y**2  # Example: F_y(y) = y²
+        Vx1 = 2  # Use a numeric constant instead of symbolic c
+        Vy1 = F_y_specific
+        phi1 = self.find_potential_for_specific_field(Vx1, Vy1)
+        cases['constant_x_component'] = (Vx1, Vy1, phi1)
+        
+        # Case 1b: Constant y-component with specific F_x
+        F_x_specific = sp.sin(self.x)  # Example: F_x(x) = sin(x)
+        Vx2 = F_x_specific
+        Vy2 = 3  # Use a numeric constant instead of symbolic c
+        phi2 = self.find_potential_for_specific_field(Vx2, Vy2)
+        cases['constant_y_component'] = (Vx2, Vy2, phi2)
+        
+        return cases
+
+
+class LinearComponentField(GradientFieldAnalyzer):
+    """Case 2: Both components are linear functions"""
+    
+    def __init__(self):
+        super().__init__()
+        # Define constants for linear functions
+        self.a1, self.b1, self.c1 = sp.symbols('a1 b1 c1', real=True)
+        self.a2, self.b2, self.c2 = sp.symbols('a2 b2 c2', real=True)
+    
+    def find_potential(self, Vx: sp.Expr = None, Vy: sp.Expr = None) -> sp.Expr:
+        """Find potential function for given linear vector field"""
+        if Vx is None or Vy is None:
+            Vx, Vy = self.get_general_linear_field()
+        
+        # Use the method from the case study
+        phi = self._find_potential_2d(Vx, Vy)
+        return phi
+    
+    def _find_potential_2d(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Implementation of find_potential_f2D from the case study"""
+        # First check if it's a gradient field
+        if not self.check_gradient_condition_for_specific(Vx, Vy):
+            raise ValueError("Field is not a gradient field - cannot find potential")
+        
+        # Method: Integrate Vx with respect to x
+        phi_x = sp.integrate(Vx, self.x)
+        
+        # Differentiate with respect to y and compare with Vy
+        diff_phi_x_y = sp.diff(phi_x, self.y)
+        remaining = Vy - diff_phi_x_y
+        
+        # Integrate remaining with respect to y
+        phi_y = sp.integrate(remaining, self.y)
+        
+        # Combine results (no additional constants needed)
+        phi = phi_x + phi_y
+        
+        return sp.simplify(phi)
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        return self.get_general_linear_field()
+    
+    def get_general_linear_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        """General linear vector field: F(x,y) = [a1*x + b1*y + c1, a2*x + b2*y + c2]"""
+        Vx = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy = self.a2 * self.x + self.b2 * self.y + self.c2
+        return Vx, Vy
+    
+    def get_gradient_condition(self) -> sp.Expr:
+        """Return the condition for the field to be a gradient field"""
+        # For a 2D field F = [P, Q] to be a gradient field, we need ∂P/∂y = ∂Q/∂x
+        Vx, Vy = self.get_general_linear_field()
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition)
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific numeric vector field using correct integration"""
+        # Use the direct integration method that works for any gradient field
+        return self._find_potential_2d(Vx, Vy)
+    
+    def get_specific_gradient_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases where the field is a gradient field"""
+        cases = {}
+        
+        # Case 2a: a2 = b1 (from the case study) - FORM 1
+        Vx1 = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy1 = self.b1 * self.x + self.b2 * self.y + self.c2  # a2 = b1
+        phi1 = self._find_potential_2d(Vx1, Vy1)
+        cases['symmetric_case_1'] = (Vx1, Vy1, phi1)
+        
+        # Case 2b: b2 = a1 (alternative symmetric case) - FORM 2  
+        Vx2 = self.a2 * self.x + self.a1 * self.y + self.c2  # swapped coefficients
+        Vy2 = self.a1 * self.x + self.b1 * self.y + self.c1  # b2 = a1
+        phi2 = self._find_potential_2d(Vx2, Vy2)
+        cases['symmetric_case_2'] = (Vx2, Vy2, phi2)
+        
+        return cases
+    
+    def check_gradient_condition_for_specific(self, Vx: sp.Expr, Vy: sp.Expr) -> bool:
+        """Check if a specific vector field satisfies the gradient condition"""
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition).equals(0)
+    
+    def demonstrate_case_study_forms(self):
+        """Demonstrate the exact forms from the case study"""
+        print("\nEXACT FORMS FROM CASE STUDY:")
+        print("=" * 50)
+        
+        # Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)
+        print("Form 1 (Equation 3.44):")
+        phi_form1 = self.a1 * self.x**2 / 2 + self.b2 * self.y**2 / 2 + self.c2 * self.y + self.x * (self.b1 * self.y + self.c1)
+        print(f"φ(x,y) = {phi_form1}")
+        
+        Vx_form1 = sp.diff(phi_form1, self.x)
+        Vy_form1 = sp.diff(phi_form1, self.y)
+        print(f"F(x,y) = ∇φ = [{Vx_form1}, {Vy_form1}]")
+        matches_form1 = Vx_form1.equals(self.a1*self.x + self.b1*self.y + self.c1) and Vy_form1.equals(self.b1*self.x + self.b2*self.y + self.c2)
+        print(f"Matches Form 1 from case study: {matches_form1}")
+        print()
+        
+        # Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)
+        print("Form 2 (Equation 3.44):")
+        phi_form2 = self.a2 * self.x**2 / 2 + self.b1 * self.y**2 / 2 + self.c1 * self.y + self.x * (self.a1 * self.y + self.c2)
+        print(f"φ(x,y) = {phi_form2}")
+        
+        Vx_form2 = sp.diff(phi_form2, self.x)
+        Vy_form2 = sp.diff(phi_form2, self.y)
+        print(f"F(x,y) = ∇φ = [{Vx_form2}, {Vy_form2}]")
+        matches_form2 = Vx_form2.equals(self.a2*self.x + self.a1*self.y + self.c2) and Vy_form2.equals(self.a1*self.x + self.b1*self.y + self.c1)
+        print(f"Matches Form 2 from case study: {matches_form2}")
+        print()
+
+
+class GradientFieldFactory:
+    """Factory class to create different types of gradient fields"""
+    
+    @staticmethod
+    def create_constant_component_field(component: str = 'x', constant: sp.Symbol = None):
+        return ConstantComponentField(component, constant)
+    
+    @staticmethod
+    def create_linear_component_field():
+        return LinearComponentField()
+    
+    @staticmethod
+    def analyze_all_cases():
+        """Analyze all cases from the case study"""
+        print("=" * 60)
+        print("GRADIENT FIELD CASE STUDY ANALYSIS")
+        print("=" * 60)
+        
+        # Case 1: Constant component
+        print("\nCASE 1: One Component is Constant")
+        print("-" * 40)
+        
+        case1_x = GradientFieldFactory.create_constant_component_field('x')
+        phi1 = case1_x.find_potential()
+        Vx1, Vy1 = case1_x.get_vector_field()
+        case1_x.display_results(phi1, Vx1, Vy1)
+        
+        case1_y = GradientFieldFactory.create_constant_component_field('y')
+        phi2 = case1_y.find_potential()
+        Vx2, Vy2 = case1_y.get_vector_field()
+        case1_y.display_results(phi2, Vx2, Vy2)
+        
+        # Show specific examples
+        print("\nSpecific Examples for Case 1:")
+        examples1 = case1_x.get_specific_cases()
+        for case_name, (Vx, Vy, phi) in examples1.items():
+            print(f"{case_name}:")
+            case1_x.display_results(phi, Vx, Vy)
+        
+        # Case 2: Linear components
+        print("\nCASE 2: Both Components are Linear")
+        print("-" * 40)
+        
+        case2 = GradientFieldFactory.create_linear_component_field()
+        
+        # Show gradient condition
+        condition = case2.get_gradient_condition()
+        print(f"Gradient Field Condition: ∂P/∂y = ∂Q/∂x → {condition} = 0")
+        print(f"This means: a2 = b1 for the general linear field")
+        
+        # Show specific gradient cases
+        print("\nSpecific Gradient Cases for Case 2:")
+        examples2 = case2.get_specific_gradient_cases()
+        for case_name, (Vx, Vy, phi) in examples2.items():
+            print(f"{case_name}:")
+            case2.display_results(phi, Vx, Vy)
+        
+        # Demonstrate the exact forms from the case study
+        case2.demonstrate_case_study_forms()
+        
+        return case1_x, case1_y, case2
+
+
+class NumericalExamples:
+    """Class to demonstrate and verify numerical examples"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y')
+        self.constant_analyzer = ConstantComponentField()
+        self.linear_analyzer = LinearComponentField()
+    
+    def run_case1_examples(self):
+        """Run numerical examples for Case 1"""
+        print("\nNumerical Examples - Case 1:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2, 3y²]
+        print("Example 1: F(x,y) = [2, 3y²]")
+        Vx1 = 2
+        Vy1 = 3 * self.y**2
+        phi1 = self.constant_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+        self.constant_analyzer.display_results(phi1, Vx1, Vy1)
+        
+        # Example 2: F(x,y) = [sin(x), 5]
+        print("Example 2: F(x,y) = [sin(x), 5]")
+        Vx2 = sp.sin(self.x)
+        Vy2 = 5
+        phi2 = self.constant_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+        self.constant_analyzer.display_results(phi2, Vx2, Vy2)
+    
+    def run_case2_examples(self):
+        """Run numerical examples for Case 2"""
+        print("\nNumerical Examples - Case 2:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2] where a2 = b1 = 3
+        print("Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2]")
+        Vx1 = 2*self.x + 3*self.y + 1
+        Vy1 = 3*self.x + 4*self.y + 2
+        
+        # Check if it's a gradient field first
+        is_gradient = self.linear_analyzer.check_gradient_condition_for_specific(Vx1, Vy1)
+        print(f"Is this a gradient field? {is_gradient}")
+        
+        if is_gradient:
+            phi1 = self.linear_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+            self.linear_analyzer.display_results(phi1, Vx1, Vy1)
+            
+            # Show that this matches Form 1 from the case study
+            print("This matches Form 1 from case study with:")
+            print("  a1 = 2, b1 = 3, c1 = 1")
+            print("  a2 = 3, b2 = 4, c2 = 2")
+            phi_form1 = 2*self.x**2/2 + 4*self.y**2/2 + 2*self.y + self.x*(3*self.y + 1)
+            print(f"  φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+            print(f"        = {sp.simplify(phi_form1)}")
+        else:
+            print("This field cannot have a potential function!")
+        print("-" * 50)
+        
+        # Example 2: F(x,y) = [x + 2y, 2x + 3y] where a2 = b1 = 2
+        print("Example 2: F(x,y) = [x + 2y, 2x + 3y]")
+        Vx2 = self.x + 2*self.y
+        Vy2 = 2*self.x + 3*self.y
+        
+        is_gradient2 = self.linear_analyzer.check_gradient_condition_for_specific(Vx2, Vy2)
+        print(f"Is this a gradient field? {is_gradient2}")
+        
+        if is_gradient2:
+            phi2 = self.linear_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+            self.linear_analyzer.display_results(phi2, Vx2, Vy2)
+        else:
+            print("This field cannot have a potential function!")
+        print("-" * 50)
+        
+        # Example 3: Non-gradient field (should fail)
+        print("Example 3: Non-gradient field F(x,y) = [x + y, 2x + y]")
+        Vx3 = self.x + self.y
+        Vy3 = 2*self.x + self.y
+        
+        is_gradient3 = self.linear_analyzer.check_gradient_condition_for_specific(Vx3, Vy3)
+        print(f"Is this a gradient field? {is_gradient3}")
+        
+        if is_gradient3:
+            print("ERROR: This should not be a gradient field!")
+            print("Let's check the gradient condition:")
+            print(f"  ∂P/∂y = {sp.diff(Vx3, self.y)}")
+            print(f"  ∂Q/∂x = {sp.diff(Vy3, self.x)}")
+            print(f"  Gradient condition satisfied? {sp.diff(Vx3, self.y).equals(sp.diff(Vy3, self.x))}")
+            
+            # Try to find a potential anyway to see what happens
+            try:
+                phi3 = self.linear_analyzer.find_potential_for_specific_field(Vx3, Vy3)
+                is_valid, diff_x, diff_y = self.linear_analyzer.verify_potential(phi3, Vx3, Vy3)
+                print(f"Attempted potential: φ(x,y) = {phi3}")
+                print(f"Verification: ∇φ = F? {is_valid}")
+                if not is_valid:
+                    print(f"  ∂φ/∂x - Vx = {diff_x}")
+                    print(f"  ∂φ/∂y - Vy = {diff_y}")
+            except ValueError as e:
+                print(f"✓ Correct: {e}")
+        else:
+            print("✓ Correct: This field cannot have a potential function!")
+            print(f"Reason: ∂P/∂y = {sp.diff(Vx3, self.y)} ≠ ∂Q/∂x = {sp.diff(Vy3, self.x)}")
+            print("The gradient condition a₂ = b₁ is not satisfied")
+            
+            # Let's manually verify what happens if we try the integration method
+            print("\nManual verification of integration method:")
+            phi_x_manual = sp.integrate(Vx3, self.x)  # ∫(x + y)dx = x²/2 + xy
+            diff_phi_x_y = sp.diff(phi_x_manual, self.y)  # ∂/∂y(x²/2 + xy) = x
+            remaining = Vy3 - diff_phi_x_y  # (2x + y) - x = x + y
+            phi_y_manual = sp.integrate(remaining, self.y)  # ∫(x + y)dy = xy + y²/2
+            phi_manual = phi_x_manual + phi_y_manual  # x²/2 + xy + xy + y²/2 = x²/2 + 2xy + y²/2
+            print(f"  φ_x = ∫Vx dx = {phi_x_manual}")
+            print(f"  ∂φ_x/∂y = {diff_phi_x_y}")
+            print(f"  remaining = Vy - ∂φ_x/∂y = {remaining}")
+            print(f"  φ_y = ∫remaining dy = {phi_y_manual}")
+            print(f"  φ = φ_x + φ_y = {phi_manual}")
+            
+            # Verify this "potential"
+            grad_x = sp.diff(phi_manual, self.x)  # x + 2y
+            grad_y = sp.diff(phi_manual, self.y)  # 2x + y
+            print(f"  ∇φ = [{grad_x}, {grad_y}]")
+            print(f"  ∇φ = F? {grad_x.equals(Vx3) and grad_y.equals(Vy3)}")
+            print(f"  This actually works! But wait, let's check the original field:")
+            print(f"  Original F = [{Vx3}, {Vy3}]")
+            print("  The issue is that for F(x,y) = [x + y, 2x + y]:")
+            print("  ∂P/∂y = 1, but ∂Q/∂x = 2")
+            print("  So this field is NOT conservative, yet we found a 'potential'")
+            print("  This reveals a bug in our integration method!")
+        print("-" * 50)
+
+
+def main():
+    # Run the complete analysis
+    analyzer1, analyzer2, analyzer3 = GradientFieldFactory.analyze_all_cases()
+    
+    # Run numerical examples
+    print("\n" + "=" * 60)
+    print("NUMERICAL EXAMPLES VERIFICATION")
+    print("=" * 60)
+    
+    numerical_examples = NumericalExamples()
+    numerical_examples.run_case1_examples()
+    numerical_examples.run_case2_examples()
+    
+    # Additional demonstration of the key insight
+    print("\n" + "=" * 60)
+    print("KEY INSIGHT FROM CASE STUDY")
+    print("=" * 60)
+    print("For linear vector fields F(x,y) = [a₁x + b₁y + c₁, a₂x + b₂y + c₂]:")
+    print("• The field is a gradient field IF AND ONLY IF a₂ = b₁")
+    print("• The potential function has two equivalent forms:")
+    print("  Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+    print("  Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)")
+    print("• These match equations (3.44) from the case study")
+    print("\nSUMMARY OF RESULTS:")
+    print("• Case 1 (constant component): Always a gradient field")
+    print("• Case 2 (linear components): Gradient field only when a₂ = b₁")
+    print("• IMPORTANT: The integration method has a bug - it can find 'potentials' for")
+    print("  non-gradient fields. Always check the gradient condition first!")
+
+
+if __name__ == "__main__":
+    main()

Case Study Constructing Gradient Fields/constructing_gradient_fields_case_1_and_2_009.py

@@ -0,0 +1,424 @@
+import sympy as sp
+from abc import ABC, abstractmethod
+from typing import Tuple, Union, Dict, List
+
+class GradientFieldAnalyzer(ABC):
+    """Abstract base class for analyzing gradient fields"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y', real=True)
+        self.X = sp.Matrix([self.x, self.y])
+    
+    @abstractmethod
+    def find_potential(self) -> sp.Expr:
+        pass
+    
+    @abstractmethod
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        pass
+    
+    def verify_potential(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr) -> Tuple[bool, sp.Expr, sp.Expr]:
+        """Verify that phi is indeed a potential function for the vector field"""
+        grad_x = sp.diff(phi, self.x)
+        grad_y = sp.diff(phi, self.y)
+        
+        diff_x = sp.simplify(grad_x - Vx)
+        diff_y = sp.simplify(grad_y - Vy)
+        
+        is_valid = diff_x.equals(0) and diff_y.equals(0)
+        return is_valid, diff_x, diff_y
+    
+    def display_results(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr):
+        """Display the results in a formatted way"""
+        print(f"Vector Field: F(x,y) = [{Vx}, {Vy}]")
+        print(f"Potential Function: φ(x,y) = {sp.simplify(phi)}")
+        
+        is_valid, diff_x, diff_y = self.verify_potential(phi, Vx, Vy)
+        print(f"Verification: ∇φ = F? {is_valid}")
+        if not is_valid:
+            print(f"  ∂φ/∂x - Vx = {diff_x}")
+            print(f"  ∂φ/∂y - Vy = {diff_y}")
+        print("-" * 50)
+
+
+class ConstantComponentField(GradientFieldAnalyzer):
+    """Case 1: One component is constant"""
+    
+    def __init__(self, constant_component: str = 'x', constant_value: sp.Symbol = None):
+        super().__init__()
+        self.constant_component = constant_component.lower()
+        self.c = constant_value if constant_value else sp.Symbol('c', real=True)
+        
+        # Define unknown functions
+        self.F_x = sp.Function('F_x')(self.x)
+        self.F_y = sp.Function('F_y')(self.y)
+    
+    def find_potential(self) -> sp.Expr:
+        if self.constant_component == 'x':
+            # F(x,y) = [c, F_y(y)]
+            phi = self.c * self.x + sp.Integral(self.F_y, self.y)
+        else:  # constant y-component
+            # F(x,y) = [F_x(x), c]
+            phi = self.c * self.y + sp.Integral(self.F_x, self.x)
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        if self.constant_component == 'x':
+            return self.c, self.F_y
+        else:
+            return self.F_x, self.c
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific vector field (not symbolic)"""
+        # Check which component is constant
+        Vx_free_symbols = Vx.free_symbols if hasattr(Vx, 'free_symbols') else set()
+        Vy_free_symbols = Vy.free_symbols if hasattr(Vy, 'free_symbols') else set()
+        
+        Vx_depends_on_x = self.x in Vx_free_symbols
+        Vx_depends_on_y = self.y in Vx_free_symbols
+        Vy_depends_on_x = self.x in Vy_free_symbols
+        Vy_depends_on_y = self.y in Vy_free_symbols
+        
+        if not Vx_depends_on_x and not Vx_depends_on_y:  # Vx is constant
+            # F(x,y) = [constant, Vy]
+            phi = Vx * self.x + sp.integrate(Vy, self.y)
+        elif not Vy_depends_on_x and not Vy_depends_on_y:  # Vy is constant
+            # F(x,y) = [Vx, constant]
+            phi = Vy * self.y + sp.integrate(Vx, self.x)
+        else:
+            raise ValueError("One component must be constant (independent of both x and y)")
+        return sp.simplify(phi)
+    
+    def get_specific_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases with actual functions"""
+        cases = {}
+        
+        # Case 1a: Constant x-component with specific F_y
+        F_y_specific = self.y**2  # Example: F_y(y) = y²
+        Vx1 = 2  # Use a numeric constant instead of symbolic c
+        Vy1 = F_y_specific
+        phi1 = self.find_potential_for_specific_field(Vx1, Vy1)
+        cases['constant_x_component'] = (Vx1, Vy1, phi1)
+        
+        # Case 1b: Constant y-component with specific F_x
+        F_x_specific = sp.sin(self.x)  # Example: F_x(x) = sin(x)
+        Vx2 = F_x_specific
+        Vy2 = 3  # Use a numeric constant instead of symbolic c
+        phi2 = self.find_potential_for_specific_field(Vx2, Vy2)
+        cases['constant_y_component'] = (Vx2, Vy2, phi2)
+        
+        return cases
+
+
+class LinearComponentField(GradientFieldAnalyzer):
+    """Case 2: Both components are linear functions"""
+    
+    def __init__(self):
+        super().__init__()
+        # Define constants for linear functions
+        self.a1, self.b1, self.c1 = sp.symbols('a1 b1 c1', real=True)
+        self.a2, self.b2, self.c2 = sp.symbols('a2 b2 c2', real=True)
+    
+    def find_potential(self, Vx: sp.Expr = None, Vy: sp.Expr = None) -> sp.Expr:
+        """Find potential function for given linear vector field"""
+        if Vx is None or Vy is None:
+            Vx, Vy = self.get_general_linear_field()
+        
+        # Use the robust method
+        phi = self._find_potential_robust(Vx, Vy)
+        return phi
+    
+    def _find_potential_robust(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Robust implementation that properly checks gradient condition"""
+        # First check if it's a gradient field
+        if not self.check_gradient_condition_for_specific(Vx, Vy):
+            raise ValueError("Field is not a gradient field - cannot find potential")
+        
+        # Method: Integrate Vx with respect to x
+        phi_x = sp.integrate(Vx, self.x)
+        
+        # Differentiate with respect to y and compare with Vy
+        diff_phi_x_y = sp.diff(phi_x, self.y)
+        remaining = Vy - diff_phi_x_y
+        
+        # CRITICAL: Check if remaining depends only on y
+        remaining_free_symbols = remaining.free_symbols if hasattr(remaining, 'free_symbols') else set()
+        if self.x in remaining_free_symbols:
+            raise ValueError(f"Field is not a gradient field - remaining term depends on x: {remaining}")
+        
+        # Integrate remaining with respect to y
+        phi_y = sp.integrate(remaining, self.y)
+        
+        # Combine results
+        phi = phi_x + phi_y
+        
+        return sp.simplify(phi)
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        return self.get_general_linear_field()
+    
+    def get_general_linear_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        """General linear vector field: F(x,y) = [a1*x + b1*y + c1, a2*x + b2*y + c2]"""
+        Vx = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy = self.a2 * self.x + self.b2 * self.y + self.c2
+        return Vx, Vy
+    
+    def get_gradient_condition(self) -> sp.Expr:
+        """Return the condition for the field to be a gradient field"""
+        # For a 2D field F = [P, Q] to be a gradient field, we need ∂P/∂y = ∂Q/∂x
+        Vx, Vy = self.get_general_linear_field()
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition)
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific numeric vector field using robust integration"""
+        return self._find_potential_robust(Vx, Vy)
+    
+    def get_specific_gradient_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases where the field is a gradient field"""
+        cases = {}
+        
+        # Case 2a: a2 = b1 (from the case study) - FORM 1
+        Vx1 = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy1 = self.b1 * self.x + self.b2 * self.y + self.c2  # a2 = b1
+        phi1 = self._find_potential_robust(Vx1, Vy1)
+        cases['symmetric_case_1'] = (Vx1, Vy1, phi1)
+        
+        # Case 2b: b2 = a1 (alternative symmetric case) - FORM 2  
+        Vx2 = self.a2 * self.x + self.a1 * self.y + self.c2  # swapped coefficients
+        Vy2 = self.a1 * self.x + self.b1 * self.y + self.c1  # b2 = a1
+        phi2 = self._find_potential_robust(Vx2, Vy2)
+        cases['symmetric_case_2'] = (Vx2, Vy2, phi2)
+        
+        return cases
+    
+    def check_gradient_condition_for_specific(self, Vx: sp.Expr, Vy: sp.Expr) -> bool:
+        """Check if a specific vector field satisfies the gradient condition"""
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition).equals(0)
+    
+    def demonstrate_case_study_forms(self):
+        """Demonstrate the exact forms from the case study"""
+        print("\nEXACT FORMS FROM CASE STUDY:")
+        print("=" * 50)
+        
+        # Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)
+        print("Form 1 (Equation 3.44):")
+        phi_form1 = self.a1 * self.x**2 / 2 + self.b2 * self.y**2 / 2 + self.c2 * self.y + self.x * (self.b1 * self.y + self.c1)
+        print(f"φ(x,y) = {phi_form1}")
+        
+        Vx_form1 = sp.diff(phi_form1, self.x)
+        Vy_form1 = sp.diff(phi_form1, self.y)
+        print(f"F(x,y) = ∇φ = [{Vx_form1}, {Vy_form1}]")
+        matches_form1 = Vx_form1.equals(self.a1*self.x + self.b1*self.y + self.c1) and Vy_form1.equals(self.b1*self.x + self.b2*self.y + self.c2)
+        print(f"Matches Form 1 from case study: {matches_form1}")
+        print()
+        
+        # Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)
+        print("Form 2 (Equation 3.44):")
+        phi_form2 = self.a2 * self.x**2 / 2 + self.b1 * self.y**2 / 2 + self.c1 * self.y + self.x * (self.a1 * self.y + self.c2)
+        print(f"φ(x,y) = {phi_form2}")
+        
+        Vx_form2 = sp.diff(phi_form2, self.x)
+        Vy_form2 = sp.diff(phi_form2, self.y)
+        print(f"F(x,y) = ∇φ = [{Vx_form2}, {Vy_form2}]")
+        matches_form2 = Vx_form2.equals(self.a2*self.x + self.a1*self.y + self.c2) and Vy_form2.equals(self.a1*self.x + self.b1*self.y + self.c1)
+        print(f"Matches Form 2 from case study: {matches_form2}")
+        print()
+
+
+class GradientFieldFactory:
+    """Factory class to create different types of gradient fields"""
+    
+    @staticmethod
+    def create_constant_component_field(component: str = 'x', constant: sp.Symbol = None):
+        return ConstantComponentField(component, constant)
+    
+    @staticmethod
+    def create_linear_component_field():
+        return LinearComponentField()
+    
+    @staticmethod
+    def analyze_all_cases():
+        """Analyze all cases from the case study"""
+        print("=" * 60)
+        print("GRADIENT FIELD CASE STUDY ANALYSIS")
+        print("=" * 60)
+        
+        # Case 1: Constant component
+        print("\nCASE 1: One Component is Constant")
+        print("-" * 40)
+        
+        case1_x = GradientFieldFactory.create_constant_component_field('x')
+        phi1 = case1_x.find_potential()
+        Vx1, Vy1 = case1_x.get_vector_field()
+        case1_x.display_results(phi1, Vx1, Vy1)
+        
+        case1_y = GradientFieldFactory.create_constant_component_field('y')
+        phi2 = case1_y.find_potential()
+        Vx2, Vy2 = case1_y.get_vector_field()
+        case1_y.display_results(phi2, Vx2, Vy2)
+        
+        # Show specific examples
+        print("\nSpecific Examples for Case 1:")
+        examples1 = case1_x.get_specific_cases()
+        for case_name, (Vx, Vy, phi) in examples1.items():
+            print(f"{case_name}:")
+            case1_x.display_results(phi, Vx, Vy)
+        
+        # Case 2: Linear components
+        print("\nCASE 2: Both Components are Linear")
+        print("-" * 40)
+        
+        case2 = GradientFieldFactory.create_linear_component_field()
+        
+        # Show gradient condition
+        condition = case2.get_gradient_condition()
+        print(f"Gradient Field Condition: ∂P/∂y = ∂Q/∂x → {condition} = 0")
+        print(f"This means: a2 = b1 for the general linear field")
+        
+        # Show specific gradient cases
+        print("\nSpecific Gradient Cases for Case 2:")
+        examples2 = case2.get_specific_gradient_cases()
+        for case_name, (Vx, Vy, phi) in examples2.items():
+            print(f"{case_name}:")
+            case2.display_results(phi, Vx, Vy)
+        
+        # Demonstrate the exact forms from the case study
+        case2.demonstrate_case_study_forms()
+        
+        return case1_x, case1_y, case2
+
+
+class NumericalExamples:
+    """Class to demonstrate and verify numerical examples"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y')
+        self.constant_analyzer = ConstantComponentField()
+        self.linear_analyzer = LinearComponentField()
+    
+    def run_case1_examples(self):
+        """Run numerical examples for Case 1"""
+        print("\nNumerical Examples - Case 1:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2, 3y²]
+        print("Example 1: F(x,y) = [2, 3y²]")
+        Vx1 = 2
+        Vy1 = 3 * self.y**2
+        phi1 = self.constant_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+        self.constant_analyzer.display_results(phi1, Vx1, Vy1)
+        
+        # Example 2: F(x,y) = [sin(x), 5]
+        print("Example 2: F(x,y) = [sin(x), 5]")
+        Vx2 = sp.sin(self.x)
+        Vy2 = 5
+        phi2 = self.constant_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+        self.constant_analyzer.display_results(phi2, Vx2, Vy2)
+    
+    def run_case2_examples(self):
+        """Run numerical examples for Case 2"""
+        print("\nNumerical Examples - Case 2:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2] where a2 = b1 = 3
+        print("Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2]")
+        Vx1 = 2*self.x + 3*self.y + 1
+        Vy1 = 3*self.x + 4*self.y + 2
+        
+        # Check if it's a gradient field first
+        is_gradient = self.linear_analyzer.check_gradient_condition_for_specific(Vx1, Vy1)
+        print(f"Is this a gradient field? {is_gradient}")
+        
+        if is_gradient:
+            phi1 = self.linear_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+            self.linear_analyzer.display_results(phi1, Vx1, Vy1)
+            
+            # Show that this matches Form 1 from the case study
+            print("This matches Form 1 from case study with:")
+            print("  a1 = 2, b1 = 3, c1 = 1")
+            print("  a2 = 3, b2 = 4, c2 = 2")
+            phi_form1 = 2*self.x**2/2 + 4*self.y**2/2 + 2*self.y + self.x*(3*self.y + 1)
+            print(f"  φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+            print(f"        = {sp.simplify(phi_form1)}")
+        else:
+            print("This field cannot have a potential function!")
+        print("-" * 50)
+        
+        # Example 2: F(x,y) = [x + 2y, 2x + 3y] where a2 = b1 = 2
+        print("Example 2: F(x,y) = [x + 2y, 2x + 3y]")
+        Vx2 = self.x + 2*self.y
+        Vy2 = 2*self.x + 3*self.y
+        
+        is_gradient2 = self.linear_analyzer.check_gradient_condition_for_specific(Vx2, Vy2)
+        print(f"Is this a gradient field? {is_gradient2}")
+        
+        if is_gradient2:
+            phi2 = self.linear_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+            self.linear_analyzer.display_results(phi2, Vx2, Vy2)
+        else:
+            print("This field cannot have a potential function!")
+        print("-" * 50)
+        
+        # Example 3: Non-gradient field (should fail)
+        print("Example 3: Non-gradient field F(x,y) = [x + y, 2x + y]")
+        Vx3 = self.x + self.y
+        Vy3 = 2*self.x + self.y
+        
+        is_gradient3 = self.linear_analyzer.check_gradient_condition_for_specific(Vx3, Vy3)
+        print(f"Is this a gradient field? {is_gradient3}")
+        
+        if is_gradient3:
+            print("ERROR: This should not be a gradient field!")
+            print("Let's check the gradient condition:")
+            print(f"  ∂P/∂y = {sp.diff(Vx3, self.y)}")
+            print(f"  ∂Q/∂x = {sp.diff(Vy3, self.x)}")
+            print(f"  Gradient condition satisfied? {sp.diff(Vx3, self.y).equals(sp.diff(Vy3, self.x))}")
+        else:
+            print("✓ Correct: This field cannot have a potential function!")
+            print(f"Reason: ∂P/∂y = {sp.diff(Vx3, self.y)} ≠ ∂Q/∂x = {sp.diff(Vy3, self.x)}")
+            print("The gradient condition a₂ = b₁ is not satisfied")
+            
+            # Test our robust integration method
+            print("\nTesting robust integration method:")
+            try:
+                phi3 = self.linear_analyzer.find_potential_for_specific_field(Vx3, Vy3)
+                print(f"Unexpected success: φ(x,y) = {phi3}")
+            except ValueError as e:
+                print(f"✓ Robust method correctly failed: {e}")
+        print("-" * 50)
+
+
+def main():
+    # Run the complete analysis
+    analyzer1, analyzer2, analyzer3 = GradientFieldFactory.analyze_all_cases()
+    
+    # Run numerical examples
+    print("\n" + "=" * 60)
+    print("NUMERICAL EXAMPLES VERIFICATION")
+    print("=" * 60)
+    
+    numerical_examples = NumericalExamples()
+    numerical_examples.run_case1_examples()
+    numerical_examples.run_case2_examples()
+    
+    # Additional demonstration of the key insight
+    print("\n" + "=" * 60)
+    print("KEY INSIGHT FROM CASE STUDY")
+    print("=" * 60)
+    print("For linear vector fields F(x,y) = [a₁x + b₁y + c₁, a₂x + b₂y + c₂]:")
+    print("• The field is a gradient field IF AND ONLY IF a₂ = b₁")
+    print("• The potential function has two equivalent forms:")
+    print("  Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+    print("  Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)")
+    print("• These match equations (3.44) from the case study")
+    print("\nSUMMARY OF RESULTS:")
+    print("• Case 1 (constant component): Always a gradient field")
+    print("• Case 2 (linear components): Gradient field only when a₂ = b₁")
+    print("• The robust integration method correctly identifies non-gradient fields")
+
+
+if __name__ == "__main__":
+    main()

Case Study Constructing Gradient Fields/constructing_gradient_fields_case_1_and_2_final.py

@@ -0,0 +1,436 @@
+import sympy as sp
+from abc import ABC, abstractmethod
+from typing import Tuple, Union, Dict, List
+
+class GradientFieldAnalyzer(ABC):
+    """Abstract base class for analyzing gradient fields"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y', real=True)
+        self.X = sp.Matrix([self.x, self.y])
+    
+    @abstractmethod
+    def find_potential(self) -> sp.Expr:
+        pass
+    
+    @abstractmethod
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        pass
+    
+    def verify_potential(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr) -> Tuple[bool, sp.Expr, sp.Expr]:
+        """Verify that phi is indeed a potential function for the vector field"""
+        grad_x = sp.diff(phi, self.x)
+        grad_y = sp.diff(phi, self.y)
+        
+        diff_x = sp.simplify(grad_x - Vx)
+        diff_y = sp.simplify(grad_y - Vy)
+        
+        is_valid = diff_x.equals(0) and diff_y.equals(0)
+        return is_valid, diff_x, diff_y
+    
+    def display_results(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr):
+        """Display the results in a formatted way"""
+        print(f"Vector Field: F(x,y) = [{Vx}, {Vy}]")
+        print(f"Potential Function: φ(x,y) = {sp.simplify(phi)}")
+        
+        is_valid, diff_x, diff_y = self.verify_potential(phi, Vx, Vy)
+        print(f"Verification: ∇φ = F? {is_valid}")
+        if not is_valid:
+            print(f"  ∂φ/∂x - Vx = {diff_x}")
+            print(f"  ∂φ/∂y - Vy = {diff_y}")
+        print("-" * 50)
+
+
+class ConstantComponentField(GradientFieldAnalyzer):
+    """Case 1: One component is constant"""
+    
+    def __init__(self, constant_component: str = 'x', constant_value: sp.Symbol = None):
+        super().__init__()
+        self.constant_component = constant_component.lower()
+        self.c = constant_value if constant_value else sp.Symbol('c', real=True)
+        
+        # Define unknown functions
+        self.F_x = sp.Function('F_x')(self.x)
+        self.F_y = sp.Function('F_y')(self.y)
+    
+    def find_potential(self) -> sp.Expr:
+        if self.constant_component == 'x':
+            # F(x,y) = [c, F_y(y)]
+            phi = self.c * self.x + sp.Integral(self.F_y, self.y)
+        else:  # constant y-component
+            # F(x,y) = [F_x(x), c]
+            phi = self.c * self.y + sp.Integral(self.F_x, self.x)
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        if self.constant_component == 'x':
+            return self.c, self.F_y
+        else:
+            return self.F_x, self.c
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific vector field (not symbolic)"""
+        # Check which component is constant
+        Vx_free_symbols = Vx.free_symbols if hasattr(Vx, 'free_symbols') else set()
+        Vy_free_symbols = Vy.free_symbols if hasattr(Vy, 'free_symbols') else set()
+        
+        Vx_depends_on_x = self.x in Vx_free_symbols
+        Vx_depends_on_y = self.y in Vx_free_symbols
+        Vy_depends_on_x = self.x in Vy_free_symbols
+        Vy_depends_on_y = self.y in Vy_free_symbols
+        
+        if not Vx_depends_on_x and not Vx_depends_on_y:  # Vx is constant
+            # F(x,y) = [constant, Vy]
+            phi = Vx * self.x + sp.integrate(Vy, self.y)
+        elif not Vy_depends_on_x and not Vy_depends_on_y:  # Vy is constant
+            # F(x,y) = [Vx, constant]
+            phi = Vy * self.y + sp.integrate(Vx, self.x)
+        else:
+            raise ValueError("One component must be constant (independent of both x and y)")
+        return sp.simplify(phi)
+    
+    def get_specific_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases with actual functions"""
+        cases = {}
+        
+        # Case 1a: Constant x-component with specific F_y
+        F_y_specific = self.y**2  # Example: F_y(y) = y²
+        Vx1 = 2  # Use a numeric constant instead of symbolic c
+        Vy1 = F_y_specific
+        phi1 = self.find_potential_for_specific_field(Vx1, Vy1)
+        cases['constant_x_component'] = (Vx1, Vy1, phi1)
+        
+        # Case 1b: Constant y-component with specific F_x
+        F_x_specific = sp.sin(self.x)  # Example: F_x(x) = sin(x)
+        Vx2 = F_x_specific
+        Vy2 = 3  # Use a numeric constant instead of symbolic c
+        phi2 = self.find_potential_for_specific_field(Vx2, Vy2)
+        cases['constant_y_component'] = (Vx2, Vy2, phi2)
+        
+        return cases
+
+
+class LinearComponentField(GradientFieldAnalyzer):
+    """Case 2: Both components are linear functions"""
+    
+    def __init__(self):
+        super().__init__()
+        # Define constants for linear functions
+        self.a1, self.b1, self.c1 = sp.symbols('a1 b1 c1', real=True)
+        self.a2, self.b2, self.c2 = sp.symbols('a2 b2 c2', real=True)
+    
+    def find_potential(self, Vx: sp.Expr = None, Vy: sp.Expr = None) -> sp.Expr:
+        """Find potential function for given linear vector field"""
+        if Vx is None or Vy is None:
+            Vx, Vy = self.get_general_linear_field()
+        
+        # Use the robust method
+        phi = self._find_potential_robust(Vx, Vy)
+        return phi
+    
+    def _find_potential_robust(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Robust implementation that properly checks gradient condition"""
+        # First check if it's a gradient field
+        if not self.check_gradient_condition_for_specific(Vx, Vy):
+            raise ValueError("Field is not a gradient field - cannot find potential")
+        
+        # Method: Integrate Vx with respect to x
+        phi_x = sp.integrate(Vx, self.x)
+        
+        # Differentiate with respect to y and compare with Vy
+        diff_phi_x_y = sp.diff(phi_x, self.y)
+        remaining = Vy - diff_phi_x_y
+        
+        # CRITICAL: Check if remaining depends only on y
+        remaining_free_symbols = remaining.free_symbols if hasattr(remaining, 'free_symbols') else set()
+        if self.x in remaining_free_symbols:
+            raise ValueError(f"Field is not a gradient field - remaining term depends on x: {remaining}")
+        
+        # Integrate remaining with respect to y
+        phi_y = sp.integrate(remaining, self.y)
+        
+        # Combine results
+        phi = phi_x + phi_y
+        
+        return sp.simplify(phi)
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        return self.get_general_linear_field()
+    
+    def get_general_linear_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        """General linear vector field: F(x,y) = [a1*x + b1*y + c1, a2*x + b2*y + c2]"""
+        Vx = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy = self.a2 * self.x + self.b2 * self.y + self.c2
+        return Vx, Vy
+    
+    def get_gradient_condition(self) -> sp.Expr:
+        """Return the condition for the field to be a gradient field"""
+        # For a 2D field F = [P, Q] to be a gradient field, we need ∂P/∂y = ∂Q/∂x
+        Vx, Vy = self.get_general_linear_field()
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition)
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific numeric vector field using robust integration"""
+        return self._find_potential_robust(Vx, Vy)
+    
+    def get_specific_gradient_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases where the field is a gradient field"""
+        cases = {}
+        
+        # Case 2a: a2 = b1 (from the case study) - FORM 1
+        Vx1 = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy1 = self.b1 * self.x + self.b2 * self.y + self.c2  # a2 = b1
+        phi1 = self._find_potential_robust(Vx1, Vy1)
+        cases['symmetric_case_1'] = (Vx1, Vy1, phi1)
+        
+        # Case 2b: b2 = a1 (alternative symmetric case) - FORM 2  
+        Vx2 = self.a2 * self.x + self.a1 * self.y + self.c2  # swapped coefficients
+        Vy2 = self.a1 * self.x + self.b1 * self.y + self.c1  # b2 = a1
+        phi2 = self._find_potential_robust(Vx2, Vy2)
+        cases['symmetric_case_2'] = (Vx2, Vy2, phi2)
+        
+        return cases
+    
+    def check_gradient_condition_for_specific(self, Vx: sp.Expr, Vy: sp.Expr) -> bool:
+        """Check if a specific vector field satisfies the gradient condition"""
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition).equals(0)
+    
+    def demonstrate_case_study_forms(self):
+        """Demonstrate the exact forms from the case study"""
+        print("\nEXACT FORMS FROM CASE STUDY:")
+        print("=" * 50)
+        
+        # Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)
+        print("Form 1 (Equation 3.44):")
+        phi_form1 = self.a1 * self.x**2 / 2 + self.b2 * self.y**2 / 2 + self.c2 * self.y + self.x * (self.b1 * self.y + self.c1)
+        print(f"φ(x,y) = {phi_form1}")
+        
+        Vx_form1 = sp.diff(phi_form1, self.x)
+        Vy_form1 = sp.diff(phi_form1, self.y)
+        print(f"F(x,y) = ∇φ = [{Vx_form1}, {Vy_form1}]")
+        matches_form1 = Vx_form1.equals(self.a1*self.x + self.b1*self.y + self.c1) and Vy_form1.equals(self.b1*self.x + self.b2*self.y + self.c2)
+        print(f"Matches Form 1 from case study: {matches_form1}")
+        print()
+        
+        # Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)
+        print("Form 2 (Equation 3.44):")
+        phi_form2 = self.a2 * self.x**2 / 2 + self.b1 * self.y**2 / 2 + self.c1 * self.y + self.x * (self.a1 * self.y + self.c2)
+        print(f"φ(x,y) = {phi_form2}")
+        
+        Vx_form2 = sp.diff(phi_form2, self.x)
+        Vy_form2 = sp.diff(phi_form2, self.y)
+        print(f"F(x,y) = ∇φ = [{Vx_form2}, {Vy_form2}]")
+        matches_form2 = Vx_form2.equals(self.a2*self.x + self.a1*self.y + self.c2) and Vy_form2.equals(self.a1*self.x + self.b1*self.y + self.c1)
+        print(f"Matches Form 2 from case study: {matches_form2}")
+        print()
+
+
+class GradientFieldFactory:
+    """Factory class to create different types of gradient fields"""
+    
+    @staticmethod
+    def create_constant_component_field(component: str = 'x', constant: sp.Symbol = None):
+        return ConstantComponentField(component, constant)
+    
+    @staticmethod
+    def create_linear_component_field():
+        return LinearComponentField()
+    
+    @staticmethod
+    def analyze_all_cases():
+        """Analyze all cases from the case study"""
+        print("=" * 60)
+        print("GRADIENT FIELD CASE STUDY ANALYSIS")
+        print("=" * 60)
+        
+        # Case 1: Constant component
+        print("\nCASE 1: One Component is Constant")
+        print("-" * 40)
+        
+        case1_x = GradientFieldFactory.create_constant_component_field('x')
+        phi1 = case1_x.find_potential()
+        Vx1, Vy1 = case1_x.get_vector_field()
+        case1_x.display_results(phi1, Vx1, Vy1)
+        
+        case1_y = GradientFieldFactory.create_constant_component_field('y')
+        phi2 = case1_y.find_potential()
+        Vx2, Vy2 = case1_y.get_vector_field()
+        case1_y.display_results(phi2, Vx2, Vy2)
+        
+        # Show specific examples
+        print("\nSpecific Examples for Case 1:")
+        examples1 = case1_x.get_specific_cases()
+        for case_name, (Vx, Vy, phi) in examples1.items():
+            print(f"{case_name}:")
+            case1_x.display_results(phi, Vx, Vy)
+        
+        # Case 2: Linear components
+        print("\nCASE 2: Both Components are Linear")
+        print("-" * 40)
+        
+        case2 = GradientFieldFactory.create_linear_component_field()
+        
+        # Show gradient condition
+        condition = case2.get_gradient_condition()
+        print(f"Gradient Field Condition: ∂P/∂y = ∂Q/∂x → {condition} = 0")
+        print(f"This means: a2 = b1 for the general linear field")
+        
+        # Show specific gradient cases
+        print("\nSpecific Gradient Cases for Case 2:")
+        examples2 = case2.get_specific_gradient_cases()
+        for case_name, (Vx, Vy, phi) in examples2.items():
+            print(f"{case_name}:")
+            case2.display_results(phi, Vx, Vy)
+        
+        # Demonstrate the exact forms from the case study
+        case2.demonstrate_case_study_forms()
+        
+        return case1_x, case1_y, case2
+
+
+class NumericalExamples:
+    """Class to demonstrate and verify numerical examples"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y')
+        self.constant_analyzer = ConstantComponentField()
+        self.linear_analyzer = LinearComponentField()
+    
+    def run_case1_examples(self):
+        """Run numerical examples for Case 1"""
+        print("\nNumerical Examples - Case 1:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2, 3y²]
+        print("Example 1: F(x,y) = [2, 3y²]")
+        Vx1 = 2
+        Vy1 = 3 * self.y**2
+        phi1 = self.constant_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+        self.constant_analyzer.display_results(phi1, Vx1, Vy1)
+        
+        # Example 2: F(x,y) = [sin(x), 5]
+        print("Example 2: F(x,y) = [sin(x), 5]")
+        Vx2 = sp.sin(self.x)
+        Vy2 = 5
+        phi2 = self.constant_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+        self.constant_analyzer.display_results(phi2, Vx2, Vy2)
+    
+    def run_case2_examples(self):
+        """Run numerical examples for Case 2"""
+        print("\nNumerical Examples - Case 2:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2] where a2 = b1 = 3
+        print("Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2]")
+        Vx1 = 2*self.x + 3*self.y + 1
+        Vy1 = 3*self.x + 4*self.y + 2
+        
+        # Check if it's a gradient field first
+        is_gradient = self.linear_analyzer.check_gradient_condition_for_specific(Vx1, Vy1)
+        print(f"Is this a gradient field? {is_gradient}")
+        
+        if is_gradient:
+            phi1 = self.linear_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+            self.linear_analyzer.display_results(phi1, Vx1, Vy1)
+            
+            # Show that this matches Form 1 from the case study
+            print("This matches Form 1 from case study with:")
+            print("  a1 = 2, b1 = 3, c1 = 1")
+            print("  a2 = 3, b2 = 4, c2 = 2")
+            phi_form1 = 2*self.x**2/2 + 4*self.y**2/2 + 2*self.y + self.x*(3*self.y + 1)
+            print(f"  φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+            print(f"        = {sp.simplify(phi_form1)}")
+        else:
+            print("This field cannot have a potential function!")
+        print("-" * 50)
+        
+        # Example 2: F(x,y) = [x + 2y, 2x + 3y] where a2 = b1 = 2
+        print("Example 2: F(x,y) = [x + 2y, 2x + 3y]")
+        Vx2 = self.x + 2*self.y
+        Vy2 = 2*self.x + 3*self.y
+        
+        is_gradient2 = self.linear_analyzer.check_gradient_condition_for_specific(Vx2, Vy2)
+        print(f"Is this a gradient field? {is_gradient2}")
+        
+        if is_gradient2:
+            phi2 = self.linear_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+            self.linear_analyzer.display_results(phi2, Vx2, Vy2)
+        else:
+            print("This field cannot have a potential function!")
+        print("-" * 50)
+        
+        # Example 3: Non-gradient field (should fail)
+        print("Example 3: Non-gradient field F(x,y) = [x + y, 2x + y]")
+        Vx3 = self.x + self.y
+        Vy3 = 2*self.x + self.y
+        
+        is_gradient3 = self.linear_analyzer.check_gradient_condition_for_specific(Vx3, Vy3)
+        print(f"Is this a gradient field? {is_gradient3}")
+        
+        if is_gradient3:
+            print("ERROR: This should not be a gradient field!")
+            print("Let's check the gradient condition:")
+            print(f"  ∂P/∂y = {sp.diff(Vx3, self.y)}")
+            print(f"  ∂Q/∂x = {sp.diff(Vy3, self.x)}")
+            print(f"  Gradient condition satisfied? {sp.diff(Vx3, self.y).equals(sp.diff(Vy3, self.x))}")
+        else:
+            print("✓ Correct: This field cannot have a potential function!")
+            print(f"Reason: ∂P/∂y = {sp.diff(Vx3, self.y)} ≠ ∂Q/∂x = {sp.diff(Vy3, self.x)}")
+            print("The gradient condition a₂ = b₁ is not satisfied")
+            
+            # Test our robust integration method
+            print("\nTesting robust integration method:")
+            try:
+                phi3 = self.linear_analyzer.find_potential_for_specific_field(Vx3, Vy3)
+                print(f"Unexpected success: φ(x,y) = {phi3}")
+            except ValueError as e:
+                print(f"✓ Robust method correctly failed: {e}")
+        print("-" * 50)
+
+
+def main():
+    # Run the complete analysis
+    analyzer1, analyzer2, analyzer3 = GradientFieldFactory.analyze_all_cases()
+    
+    # Run numerical examples
+    print("\n" + "=" * 60)
+    print("NUMERICAL EXAMPLES VERIFICATION")
+    print("=" * 60)
+    
+    numerical_examples = NumericalExamples()
+    numerical_examples.run_case1_examples()
+    numerical_examples.run_case2_examples()
+    
+    # Final summary
+    print("\n" + "=" * 60)
+    print("FINAL SUMMARY: CONSTRUCTING GRADIENT FIELDS")
+    print("=" * 60)
+    
+    print("\n✓ CASE 1: One Component Constant")
+    print("  • Always a gradient field")
+    print("  • Potential: φ(x,y) = c·x + ∫Fᵧ(y)dy  OR  φ(x,y) = c·y + ∫Fₓ(x)dx")
+    
+    print("\n✓ CASE 2: Both Components Linear")
+    print("  • Gradient field IF AND ONLY IF a₂ = b₁")
+    print("  • Potential forms:")
+    print("    Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+    print("    Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)")
+    
+    print("\n✓ KEY MATHEMATICAL INSIGHTS:")
+    print("  • Gradient condition: ∂P/∂y = ∂Q/∂x")
+    print("  • For linear fields: a₂ = b₁")
+    print("  • Robust integration method prevents false positives")
+    print("  • Matches case study equations (3.44) and (3.45)")
+    
+    print("\n✓ OBJECT-ORIENTED DESIGN:")
+    print("  • Abstract base class for extensibility")
+    print("  • Factory pattern for creating analyzers")
+    print("  • Robust verification and error handling")
+    print("  • Clear separation of symbolic and numerical analysis")
+
+
+if __name__ == "__main__":
+    main()

Case Study Constructing Gradient Fields/constructing_gradient_fields_case_1_and_2_optimized_final.py

@@ -0,0 +1,436 @@
+import sympy as sp
+from abc import ABC, abstractmethod
+from typing import Tuple, Union, Dict, List
+
+class GradientFieldAnalyzer(ABC):
+    """Abstract base class for analyzing gradient fields"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y', real=True)
+        self.X = sp.Matrix([self.x, self.y])
+    
+    @abstractmethod
+    def find_potential(self) -> sp.Expr:
+        pass
+    
+    @abstractmethod
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        pass
+    
+    def verify_potential(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr) -> Tuple[bool, sp.Expr, sp.Expr]:
+        """Verify that phi is indeed a potential function for the vector field"""
+        grad_x = sp.diff(phi, self.x)
+        grad_y = sp.diff(phi, self.y)
+        
+        diff_x = sp.simplify(grad_x - Vx)
+        diff_y = sp.simplify(grad_y - Vy)
+        
+        is_valid = diff_x.equals(0) and diff_y.equals(0)
+        return is_valid, diff_x, diff_y
+    
+    def display_results(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr):
+        """Display the results in a formatted way"""
+        print(f"Vector Field: F(x,y) = [{Vx}, {Vy}]")
+        print(f"Potential Function: φ(x,y) = {sp.simplify(phi)}")
+        
+        is_valid, diff_x, diff_y = self.verify_potential(phi, Vx, Vy)
+        print(f"Verification: ∇φ = F? {is_valid}")
+        if not is_valid:
+            print(f"  ∂φ/∂x - Vx = {diff_x}")
+            print(f"  ∂φ/∂y - Vy = {diff_y}")
+        print("-" * 50)
+
+
+class ConstantComponentField(GradientFieldAnalyzer):
+    """Case 1: One component is constant"""
+    
+    def __init__(self, constant_component: str = 'x', constant_value: sp.Symbol = None):
+        super().__init__()
+        self.constant_component = constant_component.lower()
+        self.c = constant_value if constant_value else sp.Symbol('c', real=True)
+        
+        # Define unknown functions
+        self.F_x = sp.Function('F_x')(self.x)
+        self.F_y = sp.Function('F_y')(self.y)
+    
+    def find_potential(self) -> sp.Expr:
+        if self.constant_component == 'x':
+            # F(x,y) = [c, F_y(y)]
+            phi = self.c * self.x + sp.Integral(self.F_y, self.y)
+        else:  # constant y-component
+            # F(x,y) = [F_x(x), c]
+            phi = self.c * self.y + sp.Integral(self.F_x, self.x)
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        if self.constant_component == 'x':
+            return self.c, self.F_y
+        else:
+            return self.F_x, self.c
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific vector field (not symbolic)"""
+        # Check which component is constant
+        Vx_free_symbols = Vx.free_symbols if hasattr(Vx, 'free_symbols') else set()
+        Vy_free_symbols = Vy.free_symbols if hasattr(Vy, 'free_symbols') else set()
+        
+        Vx_depends_on_x = self.x in Vx_free_symbols
+        Vx_depends_on_y = self.y in Vx_free_symbols
+        Vy_depends_on_x = self.x in Vy_free_symbols
+        Vy_depends_on_y = self.y in Vy_free_symbols
+        
+        if not Vx_depends_on_x and not Vx_depends_on_y:  # Vx is constant
+            # F(x,y) = [constant, Vy]
+            phi = Vx * self.x + sp.integrate(Vy, self.y)
+        elif not Vy_depends_on_x and not Vy_depends_on_y:  # Vy is constant
+            # F(x,y) = [Vx, constant]
+            phi = Vy * self.y + sp.integrate(Vx, self.x)
+        else:
+            raise ValueError("One component must be constant (independent of both x and y)")
+        return sp.simplify(phi)
+    
+    def get_specific_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases with actual functions"""
+        cases = {}
+        
+        # Case 1a: Constant x-component with specific F_y
+        F_y_specific = self.y**2  # Example: F_y(y) = y²
+        Vx1 = 2  # Use a numeric constant instead of symbolic c
+        Vy1 = F_y_specific
+        phi1 = self.find_potential_for_specific_field(Vx1, Vy1)
+        cases['constant_x_component'] = (Vx1, Vy1, phi1)
+        
+        # Case 1b: Constant y-component with specific F_x
+        F_x_specific = sp.sin(self.x)  # Example: F_x(x) = sin(x)
+        Vx2 = F_x_specific
+        Vy2 = 3  # Use a numeric constant instead of symbolic c
+        phi2 = self.find_potential_for_specific_field(Vx2, Vy2)
+        cases['constant_y_component'] = (Vx2, Vy2, phi2)
+        
+        return cases
+
+
+class LinearComponentField(GradientFieldAnalyzer):
+    """Case 2: Both components are linear functions"""
+    
+    def __init__(self):
+        super().__init__()
+        # Define constants for linear functions
+        self.a1, self.b1, self.c1 = sp.symbols('a1 b1 c1', real=True)
+        self.a2, self.b2, self.c2 = sp.symbols('a2 b2 c2', real=True)
+    
+    def find_potential(self, Vx: sp.Expr = None, Vy: sp.Expr = None) -> sp.Expr:
+        """Find potential function for given linear vector field"""
+        if Vx is None or Vy is None:
+            Vx, Vy = self.get_general_linear_field()
+        
+        # Use the robust method
+        phi = self._find_potential_robust(Vx, Vy)
+        return phi
+    
+    def _find_potential_robust(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Robust implementation that properly checks gradient condition"""
+        # First check if it's a gradient field
+        if not self.check_gradient_condition_for_specific(Vx, Vy):
+            raise ValueError("Field is not a gradient field - cannot find potential")
+        
+        # Method: Integrate Vx with respect to x
+        phi_x = sp.integrate(Vx, self.x)
+        
+        # Differentiate with respect to y and compare with Vy
+        diff_phi_x_y = sp.diff(phi_x, self.y)
+        remaining = Vy - diff_phi_x_y
+        
+        # CRITICAL: Check if remaining depends only on y
+        remaining_free_symbols = remaining.free_symbols if hasattr(remaining, 'free_symbols') else set()
+        if self.x in remaining_free_symbols:
+            raise ValueError(f"Field is not a gradient field - remaining term depends on x: {remaining}")
+        
+        # Integrate remaining with respect to y
+        phi_y = sp.integrate(remaining, self.y)
+        
+        # Combine results
+        phi = phi_x + phi_y
+        
+        return sp.simplify(phi)
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        return self.get_general_linear_field()
+    
+    def get_general_linear_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        """General linear vector field: F(x,y) = [a1*x + b1*y + c1, a2*x + b2*y + c2]"""
+        Vx = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy = self.a2 * self.x + self.b2 * self.y + self.c2
+        return Vx, Vy
+    
+    def get_gradient_condition(self) -> sp.Expr:
+        """Return the condition for the field to be a gradient field"""
+        # For a 2D field F = [P, Q] to be a gradient field, we need ∂P/∂y = ∂Q/∂x
+        Vx, Vy = self.get_general_linear_field()
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition)
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific numeric vector field using robust integration"""
+        return self._find_potential_robust(Vx, Vy)
+    
+    def get_specific_gradient_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases where the field is a gradient field"""
+        cases = {}
+        
+        # Case 2a: a2 = b1 (from the case study) - FORM 1
+        Vx1 = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy1 = self.b1 * self.x + self.b2 * self.y + self.c2  # a2 = b1
+        phi1 = self._find_potential_robust(Vx1, Vy1)
+        cases['symmetric_case_1'] = (Vx1, Vy1, phi1)
+        
+        # Case 2b: b2 = a1 (alternative symmetric case) - FORM 2  
+        Vx2 = self.a2 * self.x + self.a1 * self.y + self.c2  # swapped coefficients
+        Vy2 = self.a1 * self.x + self.b1 * self.y + self.c1  # b2 = a1
+        phi2 = self._find_potential_robust(Vx2, Vy2)
+        cases['symmetric_case_2'] = (Vx2, Vy2, phi2)
+        
+        return cases
+    
+    def check_gradient_condition_for_specific(self, Vx: sp.Expr, Vy: sp.Expr) -> bool:
+        """Check if a specific vector field satisfies the gradient condition"""
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition).equals(0)
+    
+    def demonstrate_case_study_forms(self):
+        """Demonstrate the exact forms from the case study"""
+        print("\nEXACT FORMS FROM CASE STUDY:")
+        print("=" * 50)
+        
+        # Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)
+        print("Form 1 (Equation 3.44):")
+        phi_form1 = self.a1 * self.x**2 / 2 + self.b2 * self.y**2 / 2 + self.c2 * self.y + self.x * (self.b1 * self.y + self.c1)
+        print(f"φ(x,y) = {phi_form1}")
+        
+        Vx_form1 = sp.diff(phi_form1, self.x)
+        Vy_form1 = sp.diff(phi_form1, self.y)
+        print(f"F(x,y) = ∇φ = [{Vx_form1}, {Vy_form1}]")
+        matches_form1 = Vx_form1.equals(self.a1*self.x + self.b1*self.y + self.c1) and Vy_form1.equals(self.b1*self.x + self.b2*self.y + self.c2)
+        print(f"Matches Form 1 from case study: {matches_form1}")
+        print()
+        
+        # Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)
+        print("Form 2 (Equation 3.44):")
+        phi_form2 = self.a2 * self.x**2 / 2 + self.b1 * self.y**2 / 2 + self.c1 * self.y + self.x * (self.a1 * self.y + self.c2)
+        print(f"φ(x,y) = {phi_form2}")
+        
+        Vx_form2 = sp.diff(phi_form2, self.x)
+        Vy_form2 = sp.diff(phi_form2, self.y)
+        print(f"F(x,y) = ∇φ = [{Vx_form2}, {Vy_form2}]")
+        matches_form2 = Vx_form2.equals(self.a2*self.x + self.a1*self.y + self.c2) and Vy_form2.equals(self.a1*self.x + self.b1*self.y + self.c1)
+        print(f"Matches Form 2 from case study: {matches_form2}")
+        print()
+
+
+class GradientFieldFactory:
+    """Factory class to create different types of gradient fields"""
+    
+    @staticmethod
+    def create_constant_component_field(component: str = 'x', constant: sp.Symbol = None):
+        return ConstantComponentField(component, constant)
+    
+    @staticmethod
+    def create_linear_component_field():
+        return LinearComponentField()
+    
+    @staticmethod
+    def analyze_all_cases():
+        """Analyze all cases from the case study"""
+        print("=" * 60)
+        print("GRADIENT FIELD CASE STUDY ANALYSIS")
+        print("=" * 60)
+        
+        # Case 1: Constant component
+        print("\nCASE 1: One Component is Constant")
+        print("-" * 40)
+        
+        case1_x = GradientFieldFactory.create_constant_component_field('x')
+        phi1 = case1_x.find_potential()
+        Vx1, Vy1 = case1_x.get_vector_field()
+        case1_x.display_results(phi1, Vx1, Vy1)
+        
+        case1_y = GradientFieldFactory.create_constant_component_field('y')
+        phi2 = case1_y.find_potential()
+        Vx2, Vy2 = case1_y.get_vector_field()
+        case1_y.display_results(phi2, Vx2, Vy2)
+        
+        # Show specific examples
+        print("\nSpecific Examples for Case 1:")
+        examples1 = case1_x.get_specific_cases()
+        for case_name, (Vx, Vy, phi) in examples1.items():
+            print(f"{case_name}:")
+            case1_x.display_results(phi, Vx, Vy)
+        
+        # Case 2: Linear components
+        print("\nCASE 2: Both Components are Linear")
+        print("-" * 40)
+        
+        case2 = GradientFieldFactory.create_linear_component_field()
+        
+        # Show gradient condition
+        condition = case2.get_gradient_condition()
+        print(f"Gradient Field Condition: ∂P/∂y = ∂Q/∂x → {condition} = 0")
+        print(f"This means: a2 = b1 for the general linear field")
+        
+        # Show specific gradient cases
+        print("\nSpecific Gradient Cases for Case 2:")
+        examples2 = case2.get_specific_gradient_cases()
+        for case_name, (Vx, Vy, phi) in examples2.items():
+            print(f"{case_name}:")
+            case2.display_results(phi, Vx, Vy)
+        
+        # Demonstrate the exact forms from the case study
+        case2.demonstrate_case_study_forms()
+        
+        return case1_x, case1_y, case2
+
+
+class NumericalExamples:
+    """Class to demonstrate and verify numerical examples"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y')
+        self.constant_analyzer = ConstantComponentField()
+        self.linear_analyzer = LinearComponentField()
+    
+    def run_case1_examples(self):
+        """Run numerical examples for Case 1"""
+        print("\nNumerical Examples - Case 1:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2, 3y²]
+        print("Example 1: F(x,y) = [2, 3y²]")
+        Vx1 = 2
+        Vy1 = 3 * self.y**2
+        phi1 = self.constant_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+        self.constant_analyzer.display_results(phi1, Vx1, Vy1)
+        
+        # Example 2: F(x,y) = [sin(x), 5]
+        print("Example 2: F(x,y) = [sin(x), 5]")
+        Vx2 = sp.sin(self.x)
+        Vy2 = 5
+        phi2 = self.constant_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+        self.constant_analyzer.display_results(phi2, Vx2, Vy2)
+    
+    def run_case2_examples(self):
+        """Run numerical examples for Case 2"""
+        print("\nNumerical Examples - Case 2:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2] where a2 = b1 = 3
+        print("Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2]")
+        Vx1 = 2*self.x + 3*self.y + 1
+        Vy1 = 3*self.x + 4*self.y + 2
+        
+        # Check if it's a gradient field first
+        is_gradient = self.linear_analyzer.check_gradient_condition_for_specific(Vx1, Vy1)
+        print(f"Is this a gradient field? {is_gradient}")
+        
+        if is_gradient:
+            phi1 = self.linear_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+            self.linear_analyzer.display_results(phi1, Vx1, Vy1)
+            
+            # Show that this matches Form 1 from the case study
+            print("This matches Form 1 from case study with:")
+            print("  a1 = 2, b1 = 3, c1 = 1")
+            print("  a2 = 3, b2 = 4, c2 = 2")
+            phi_form1 = 2*self.x**2/2 + 4*self.y**2/2 + 2*self.y + self.x*(3*self.y + 1)
+            print(f"  φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+            print(f"        = {sp.simplify(phi_form1)}")
+        else:
+            print("This field cannot have a potential function!")
+        print("-" * 50)
+        
+        # Example 2: F(x,y) = [x + 2y, 2x + 3y] where a2 = b1 = 2
+        print("Example 2: F(x,y) = [x + 2y, 2x + 3y]")
+        Vx2 = self.x + 2*self.y
+        Vy2 = 2*self.x + 3*self.y
+        
+        is_gradient2 = self.linear_analyzer.check_gradient_condition_for_specific(Vx2, Vy2)
+        print(f"Is this a gradient field? {is_gradient2}")
+        
+        if is_gradient2:
+            phi2 = self.linear_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+            self.linear_analyzer.display_results(phi2, Vx2, Vy2)
+        else:
+            print("This field cannot have a potential function!")
+        print("-" * 50)
+        
+        # Example 3: Non-gradient field (should fail)
+        print("Example 3: Non-gradient field F(x,y) = [x + y, 2x + y]")
+        Vx3 = self.x + self.y
+        Vy3 = 2*self.x + self.y
+        
+        is_gradient3 = self.linear_analyzer.check_gradient_condition_for_specific(Vx3, Vy3)
+        print(f"Is this a gradient field? {is_gradient3}")
+        
+        if is_gradient3:
+            print("ERROR: This should not be a gradient field!")
+            print("Let's check the gradient condition:")
+            print(f"  ∂P/∂y = {sp.diff(Vx3, self.y)}")
+            print(f"  ∂Q/∂x = {sp.diff(Vy3, self.x)}")
+            print(f"  Gradient condition satisfied? {sp.diff(Vx3, self.y).equals(sp.diff(Vy3, self.x))}")
+        else:
+            print("✓ Correct: This field cannot have a potential function!")
+            print(f"Reason: ∂P/∂y = {sp.diff(Vx3, self.y)} ≠ ∂Q/∂x = {sp.diff(Vy3, self.x)}")
+            print("The gradient condition a₂ = b₁ is not satisfied")
+            
+            # Test our robust integration method
+            print("\nTesting robust integration method:")
+            try:
+                phi3 = self.linear_analyzer.find_potential_for_specific_field(Vx3, Vy3)
+                print(f"Unexpected success: φ(x,y) = {phi3}")
+            except ValueError as e:
+                print(f"✓ Robust method correctly failed: {e}")
+        print("-" * 50)
+
+
+def main():
+    # Run the complete analysis
+    analyzer1, analyzer2, analyzer3 = GradientFieldFactory.analyze_all_cases()
+    
+    # Run numerical examples
+    print("\n" + "=" * 60)
+    print("NUMERICAL EXAMPLES VERIFICATION")
+    print("=" * 60)
+    
+    numerical_examples = NumericalExamples()
+    numerical_examples.run_case1_examples()
+    numerical_examples.run_case2_examples()
+    
+    # Final summary
+    print("\n" + "=" * 60)
+    print("FINAL SUMMARY: CONSTRUCTING GRADIENT FIELDS")
+    print("=" * 60)
+    
+    print("\n✓ CASE 1: One Component Constant")
+    print("  • Always a gradient field")
+    print("  • Potential: φ(x,y) = c·x + ∫Fᵧ(y)dy  OR  φ(x,y) = c·y + ∫Fₓ(x)dx")
+    
+    print("\n✓ CASE 2: Both Components Linear")
+    print("  • Gradient field IF AND ONLY IF a₂ = b₁")
+    print("  • Potential forms:")
+    print("    Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+    print("    Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)")
+    
+    print("\n✓ KEY MATHEMATICAL INSIGHTS:")
+    print("  • Gradient condition: ∂P/∂y = ∂Q/∂x")
+    print("  • For linear fields: a₂ = b₁")
+    print("  • Robust integration method prevents false positives")
+    print("  • Matches case study equations (3.44) and (3.45)")
+    
+    print("\n✓ OBJECT-ORIENTED DESIGN:")
+    print("  • Abstract base class for extensibility")
+    print("  • Factory pattern for creating analyzers")
+    print("  • Robust verification and error handling")
+    print("  • Clear separation of symbolic and numerical analysis")
+
+
+if __name__ == "__main__":
+    main()

Case Study Constructing Gradient Fields/requirements.txt

@@ -0,0 +1 @@
+sympy 

Case Study Constructing Gradient Fields/test_corrected_examples.py

@@ -0,0 +1,43 @@
+import sympy as sp 
+
+# Test the corrected numerical examples separately
+def test_corrected_examples():
+    x, y = sp.symbols('x y')
+    
+    print("Testing Corrected Numerical Examples:")
+    print("=" * 50)
+    
+    # Case 1 Example: F(x,y) = [2, 3y²]
+    print("Case 1: F(x,y) = [2, 3y²]")
+    Vx = 2
+    Vy = 3 * y**2
+    
+    # Manual calculation: φ = ∫2 dx + ∫3y² dy = 2x + y³
+    phi_manual = 2*x + y**3
+    
+    # Verify
+    print(f"∂φ/∂x = {sp.diff(phi_manual, x)} = Vx? {sp.diff(phi_manual, x) == Vx}")
+    print(f"∂φ/∂y = {sp.diff(phi_manual, y)} = Vy? {sp.diff(phi_manual, y) == Vy}")
+    print()
+    
+    # Case 2 Example: F(x,y) = [2x + 3y + 1, 3x + 4y + 2]
+    print("Case 2: F(x,y) = [2x + 3y + 1, 3x + 4y + 2]")
+    Vx2 = 2*x + 3*y + 1
+    Vy2 = 3*x + 4*y + 2
+    
+    # Check gradient condition: ∂P/∂y = 3, ∂Q/∂x = 3 → equal, so gradient field exists
+    print(f"Gradient condition: ∂P/∂y = {sp.diff(Vx2, y)}, ∂Q/∂x = {sp.diff(Vy2, x)}")
+    print(f"Field is gradient? {sp.diff(Vx2, y) == sp.diff(Vy2, x)}")
+    
+    # Find potential using our method
+    phi_x = sp.integrate(Vx2, x)  # ∫(2x + 3y + 1)dx = x² + 3xy + x
+    remaining = Vy2 - sp.diff(phi_x, y)  # (3x + 4y + 2) - 3x = 4y + 2
+    phi_y = sp.integrate(remaining, y)  # ∫(4y + 2)dy = 2y² + 2y
+    phi_calculated = phi_x + phi_y  # x² + 3xy + x + 2y² + 2y
+    
+    print(f"Calculated potential: φ = {phi_calculated}")
+    print(f"∂φ/∂x = {sp.diff(phi_calculated, x)} = Vx? {sp.diff(phi_calculated, x) == Vx2}")
+    print(f"∂φ/∂y = {sp.diff(phi_calculated, y)} = Vy? {sp.diff(phi_calculated, y) == Vy2}")
+
+# Run the test
+test_corrected_examples()

app.py

@@ -0,0 +1,507 @@
+import sys
+import io
+from contextlib import redirect_stdout
+from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, 
+                             QHBoxLayout, QTabWidget, QTextEdit, QPushButton, 
+                             QGroupBox, QLabel, QComboBox, QSpinBox, QDoubleSpinBox,
+                             QLineEdit, QFormLayout, QSplitter, QMessageBox)
+from PyQt5.QtCore import Qt
+from PyQt5.QtGui import QFont, QTextCursor
+
+# Import the original script components
+import sympy as sp
+from constructing_gradient_fields_case_1_and_2_optimized_final import (
+    GradientFieldFactory, NumericalExamples, ConstantComponentField, LinearComponentField
+)
+
+class GradientFieldApp(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.initUI()
+        
+    def initUI(self):
+        self.setWindowTitle('Gradient Field Analyzer')
+        self.setGeometry(100, 100, 1200, 800)
+        
+        # Central widget and main layout
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        main_layout = QVBoxLayout(central_widget)
+        
+        # Title
+        title_label = QLabel('Gradient Field Analyzer')
+        title_label.setAlignment(Qt.AlignCenter)
+        title_font = QFont()
+        title_font.setPointSize(16)
+        title_font.setBold(True)
+        title_label.setFont(title_font)
+        main_layout.addWidget(title_label)
+        
+        # Create tab widget
+        self.tabs = QTabWidget()
+        main_layout.addWidget(self.tabs)
+        
+        # Create tabs
+        self.create_analysis_tab()
+        self.create_case1_tab()
+        self.create_case2_tab()
+        self.create_numerical_examples_tab()
+        
+        # Status bar
+        self.statusBar().showMessage('Ready')
+        
+    def create_analysis_tab(self):
+        """Tab for running the complete analysis"""
+        tab = QWidget()
+        layout = QVBoxLayout(tab)
+        
+        # Description
+        desc_label = QLabel(
+            "Run the complete gradient field analysis from the case study. "
+            "This will analyze both Case 1 (one constant component) and "
+            "Case 2 (both linear components)."
+        )
+        desc_label.setWordWrap(True)
+        layout.addWidget(desc_label)
+        
+        # Run analysis button
+        run_btn = QPushButton('Run Complete Analysis')
+        run_btn.clicked.connect(self.run_complete_analysis)
+        layout.addWidget(run_btn)
+        
+        # Output area
+        self.analysis_output = QTextEdit()
+        self.analysis_output.setReadOnly(True)
+        layout.addWidget(self.analysis_output)
+        
+        self.tabs.addTab(tab, "Complete Analysis")
+        
+    def create_case1_tab(self):
+        """Tab for Case 1: One constant component"""
+        tab = QWidget()
+        layout = QVBoxLayout(tab)
+        
+        # Description
+        desc_label = QLabel(
+            "Case 1: One component of the vector field is constant. "
+            "The potential function can be found by direct integration."
+        )
+        desc_label.setWordWrap(True)
+        layout.addWidget(desc_label)
+        
+        # Input form
+        form_group = QGroupBox("Vector Field Parameters")
+        form_layout = QFormLayout(form_group)
+        
+        # Component selection
+        self.case1_component = QComboBox()
+        self.case1_component.addItems(['x', 'y'])
+        form_layout.addRow("Constant Component:", self.case1_component)
+        
+        # Constant value
+        self.case1_constant = QLineEdit()
+        self.case1_constant.setText('2')
+        form_layout.addRow("Constant Value:", self.case1_constant)
+        
+        # Function for non-constant component
+        self.case1_function = QLineEdit()
+        self.case1_function.setText('y**2')
+        form_layout.addRow("Function (for non-constant component):", self.case1_function)
+        
+        layout.addWidget(form_group)
+        
+        # Buttons
+        btn_layout = QHBoxLayout()
+        
+        analyze_btn = QPushButton('Analyze Case 1')
+        analyze_btn.clicked.connect(self.analyze_case1)
+        btn_layout.addWidget(analyze_btn)
+        
+        symbolic_btn = QPushButton('Show Symbolic Analysis')
+        symbolic_btn.clicked.connect(self.show_symbolic_case1)
+        btn_layout.addWidget(symbolic_btn)
+        
+        layout.addLayout(btn_layout)
+        
+        # Output area
+        self.case1_output = QTextEdit()
+        self.case1_output.setReadOnly(True)
+        layout.addWidget(self.case1_output)
+        
+        self.tabs.addTab(tab, "Case 1")
+        
+    def create_case2_tab(self):
+        """Tab for Case 2: Both linear components"""
+        tab = QWidget()
+        layout = QVBoxLayout(tab)
+        
+        # Description
+        desc_label = QLabel(
+            "Case 2: Both components of the vector field are linear functions. "
+            "The field is a gradient field if and only if a₂ = b₁."
+        )
+        desc_label.setWordWrap(True)
+        layout.addWidget(desc_label)
+        
+        # Input form
+        form_group = QGroupBox("Vector Field Parameters")
+        form_layout = QFormLayout(form_group)
+        
+        # Coefficients for Vx = a1*x + b1*y + c1
+        self.case2_a1 = QLineEdit()
+        self.case2_a1.setText('2')
+        form_layout.addRow("a₁ (coefficient of x in Vx):", self.case2_a1)
+        
+        self.case2_b1 = QLineEdit()
+        self.case2_b1.setText('3')
+        form_layout.addRow("b₁ (coefficient of y in Vx):", self.case2_b1)
+        
+        self.case2_c1 = QLineEdit()
+        self.case2_c1.setText('1')
+        form_layout.addRow("c₁ (constant in Vx):", self.case2_c1)
+        
+        # Coefficients for Vy = a2*x + b2*y + c2
+        self.case2_a2 = QLineEdit()
+        self.case2_a2.setText('3')
+        form_layout.addRow("a₂ (coefficient of x in Vy):", self.case2_a2)
+        
+        self.case2_b2 = QLineEdit()
+        self.case2_b2.setText('4')
+        form_layout.addRow("b₂ (coefficient of y in Vy):", self.case2_b2)
+        
+        self.case2_c2 = QLineEdit()
+        self.case2_c2.setText('2')
+        form_layout.addRow("c₂ (constant in Vy):", self.case2_c2)
+        
+        layout.addWidget(form_group)
+        
+        # Buttons
+        btn_layout = QHBoxLayout()
+        
+        analyze_btn = QPushButton('Analyze Case 2')
+        analyze_btn.clicked.connect(self.analyze_case2)
+        btn_layout.addWidget(analyze_btn)
+        
+        symbolic_btn = QPushButton('Show Symbolic Analysis')
+        symbolic_btn.clicked.connect(self.show_symbolic_case2)
+        btn_layout.addWidget(symbolic_btn)
+        
+        check_btn = QPushButton('Check Gradient Condition')
+        check_btn.clicked.connect(self.check_gradient_condition)
+        btn_layout.addWidget(check_btn)
+        
+        layout.addLayout(btn_layout)
+        
+        # Output area
+        self.case2_output = QTextEdit()
+        self.case2_output.setReadOnly(True)
+        layout.addWidget(self.case2_output)
+        
+        self.tabs.addTab(tab, "Case 2")
+        
+    def create_numerical_examples_tab(self):
+        """Tab for running numerical examples"""
+        tab = QWidget()
+        layout = QVBoxLayout(tab)
+        
+        # Description
+        desc_label = QLabel(
+            "Run numerical examples to verify the gradient field analysis. "
+            "These examples demonstrate both valid gradient fields and non-gradient fields."
+        )
+        desc_label.setWordWrap(True)
+        layout.addWidget(desc_label)
+        
+        # Buttons
+        btn_layout = QHBoxLayout()
+        
+        case1_examples_btn = QPushButton('Run Case 1 Examples')
+        case1_examples_btn.clicked.connect(self.run_case1_examples)
+        btn_layout.addWidget(case1_examples_btn)
+        
+        case2_examples_btn = QPushButton('Run Case 2 Examples')
+        case2_examples_btn.clicked.connect(self.run_case2_examples)
+        btn_layout.addWidget(case2_examples_btn)
+        
+        all_examples_btn = QPushButton('Run All Examples')
+        all_examples_btn.clicked.connect(self.run_all_examples)
+        btn_layout.addWidget(all_examples_btn)
+        
+        layout.addLayout(btn_layout)
+        
+        # Output area
+        self.examples_output = QTextEdit()
+        self.examples_output.setReadOnly(True)
+        layout.addWidget(self.examples_output)
+        
+        self.tabs.addTab(tab, "Numerical Examples")
+        
+    def run_complete_analysis(self):
+        """Run the complete analysis from the original script"""
+        self.analysis_output.clear()
+        
+        # Capture stdout to display in the text area
+        output = io.StringIO()
+        with redirect_stdout(output):
+            try:
+                analyzer1, analyzer2, analyzer3 = GradientFieldFactory.analyze_all_cases()
+                self.statusBar().showMessage('Complete analysis finished successfully')
+            except Exception as e:
+                print(f"Error during analysis: {e}")
+                self.statusBar().showMessage(f'Error: {e}')
+        
+        self.analysis_output.setPlainText(output.getvalue())
+        
+    def analyze_case1(self):
+        """Analyze a specific Case 1 example"""
+        self.case1_output.clear()
+        
+        try:
+            # Get parameters from UI
+            component = self.case1_component.currentText()
+            constant = float(self.case1_constant.text())
+            function_str = self.case1_function.text()
+            
+            # Create analyzer
+            analyzer = ConstantComponentField(component)
+            
+            # Create vector field
+            x, y = sp.symbols('x y')
+            if component == 'x':
+                Vx = constant
+                Vy = sp.sympify(function_str)
+            else:
+                Vx = sp.sympify(function_str)
+                Vy = constant
+                
+            # Find potential
+            phi = analyzer.find_potential_for_specific_field(Vx, Vy)
+            
+            # Display results
+            output = f"Case 1 Analysis:\n"
+            output += f"Vector Field: F(x,y) = [{Vx}, {Vy}]\n"
+            output += f"Potential Function: φ(x,y) = {sp.simplify(phi)}\n\n"
+            
+            # Verify
+            is_valid, diff_x, diff_y = analyzer.verify_potential(phi, Vx, Vy)
+            output += f"Verification: ∇φ = F? {is_valid}\n"
+            if not is_valid:
+                output += f"  ∂φ/∂x - Vx = {diff_x}\n"
+                output += f"  ∂φ/∂y - Vy = {diff_y}\n"
+            
+            self.case1_output.setPlainText(output)
+            self.statusBar().showMessage('Case 1 analysis completed')
+            
+        except Exception as e:
+            self.case1_output.setPlainText(f"Error: {e}")
+            self.statusBar().showMessage(f'Error in Case 1 analysis: {e}')
+    
+    def show_symbolic_case1(self):
+        """Show symbolic analysis for Case 1"""
+        self.case1_output.clear()
+        
+        try:
+            component = self.case1_component.currentText()
+            analyzer = ConstantComponentField(component)
+            
+            # Get symbolic results
+            phi = analyzer.find_potential()
+            Vx, Vy = analyzer.get_vector_field()
+            
+            output = f"Symbolic Analysis for Case 1:\n"
+            output += f"Vector Field: F(x,y) = [{Vx}, {Vy}]\n"
+            output += f"Potential Function: φ(x,y) = {phi}\n\n"
+            
+            # Show specific cases
+            output += "Specific Examples:\n"
+            examples = analyzer.get_specific_cases()
+            for case_name, (Vx_ex, Vy_ex, phi_ex) in examples.items():
+                output += f"{case_name}:\n"
+                output += f"  F(x,y) = [{Vx_ex}, {Vy_ex}]\n"
+                output += f"  φ(x,y) = {phi_ex}\n\n"
+            
+            self.case1_output.setPlainText(output)
+            self.statusBar().showMessage('Symbolic Case 1 analysis completed')
+            
+        except Exception as e:
+            self.case1_output.setPlainText(f"Error: {e}")
+            self.statusBar().showMessage(f'Error in symbolic Case 1 analysis: {e}')
+    
+    def analyze_case2(self):
+        """Analyze a specific Case 2 example"""
+        self.case2_output.clear()
+        
+        try:
+            # Get parameters from UI
+            a1 = float(self.case2_a1.text())
+            b1 = float(self.case2_b1.text())
+            c1 = float(self.case2_c1.text())
+            a2 = float(self.case2_a2.text())
+            b2 = float(self.case2_b2.text())
+            c2 = float(self.case2_c2.text())
+            
+            # Create analyzer
+            analyzer = LinearComponentField()
+            x, y = sp.symbols('x y')
+            
+            # Create vector field
+            Vx = a1*x + b1*y + c1
+            Vy = a2*x + b2*y + c2
+            
+            output = f"Case 2 Analysis:\n"
+            output += f"Vector Field: F(x,y) = [{Vx}, {Vy}]\n\n"
+            
+            # Check gradient condition
+            is_gradient = analyzer.check_gradient_condition_for_specific(Vx, Vy)
+            output += f"Gradient Field Condition: ∂P/∂y = ∂Q/∂x\n"
+            output += f"  ∂P/∂y = {sp.diff(Vx, y)}\n"
+            output += f"  ∂Q/∂x = {sp.diff(Vy, x)}\n"
+            output += f"  Condition satisfied? {is_gradient}\n\n"
+            
+            if is_gradient:
+                # Find potential
+                phi = analyzer.find_potential_for_specific_field(Vx, Vy)
+                output += f"Potential Function: φ(x,y) = {sp.simplify(phi)}\n\n"
+                
+                # Verify
+                is_valid, diff_x, diff_y = analyzer.verify_potential(phi, Vx, Vy)
+                output += f"Verification: ∇φ = F? {is_valid}\n"
+                if not is_valid:
+                    output += f"  ∂φ/∂x - Vx = {diff_x}\n"
+                    output += f"  ∂φ/∂y - Vy = {diff_y}\n"
+            else:
+                output += "This field is not a gradient field. No potential function exists.\n"
+            
+            self.case2_output.setPlainText(output)
+            self.statusBar().showMessage('Case 2 analysis completed')
+            
+        except Exception as e:
+            self.case2_output.setPlainText(f"Error: {e}")
+            self.statusBar().showMessage(f'Error in Case 2 analysis: {e}')
+    
+    def show_symbolic_case2(self):
+        """Show symbolic analysis for Case 2"""
+        self.case2_output.clear()
+        
+        try:
+            analyzer = LinearComponentField()
+            
+            output = "Symbolic Analysis for Case 2:\n\n"
+            
+            # Show gradient condition
+            condition = analyzer.get_gradient_condition()
+            output += f"Gradient Field Condition: {condition} = 0\n"
+            output += "This means: a₂ = b₁ for the general linear field\n\n"
+            
+            # Show specific gradient cases
+            output += "Specific Gradient Cases:\n"
+            examples = analyzer.get_specific_gradient_cases()
+            for case_name, (Vx, Vy, phi) in examples.items():
+                output += f"{case_name}:\n"
+                output += f"  F(x,y) = [{Vx}, {Vy}]\n"
+                output += f"  φ(x,y) = {phi}\n\n"
+            
+            # Show case study forms
+            output += "Exact Forms from Case Study:\n"
+            output_stream = io.StringIO()
+            with redirect_stdout(output_stream):
+                analyzer.demonstrate_case_study_forms()
+            output += output_stream.getvalue()
+            
+            self.case2_output.setPlainText(output)
+            self.statusBar().showMessage('Symbolic Case 2 analysis completed')
+            
+        except Exception as e:
+            self.case2_output.setPlainText(f"Error: {e}")
+            self.statusBar().showMessage(f'Error in symbolic Case 2 analysis: {e}')
+    
+    def check_gradient_condition(self):
+        """Check only the gradient condition for Case 2"""
+        try:
+            # Get parameters from UI
+            a1 = float(self.case2_a1.text())
+            b1 = float(self.case2_b1.text())
+            a2 = float(self.case2_a2.text())
+            
+            # Check condition
+            condition_satisfied = abs(a2 - b1) < 1e-10  # Account for floating point errors
+            
+            if condition_satisfied:
+                message = f"✓ Gradient condition satisfied: a₂ ({a2}) = b₁ ({b1})"
+                QMessageBox.information(self, "Gradient Condition", message)
+            else:
+                message = f"✗ Gradient condition not satisfied: a₂ ({a2}) ≠ b₁ ({b1})"
+                QMessageBox.warning(self, "Gradient Condition", message)
+                
+        except Exception as e:
+            QMessageBox.critical(self, "Error", f"Error checking gradient condition: {e}")
+    
+    def run_case1_examples(self):
+        """Run Case 1 numerical examples"""
+        self.examples_output.clear()
+        
+        output = io.StringIO()
+        with redirect_stdout(output):
+            try:
+                numerical_examples = NumericalExamples()
+                numerical_examples.run_case1_examples()
+                self.statusBar().showMessage('Case 1 examples completed')
+            except Exception as e:
+                print(f"Error running Case 1 examples: {e}")
+                self.statusBar().showMessage(f'Error: {e}')
+        
+        self.examples_output.setPlainText(output.getvalue())
+    
+    def run_case2_examples(self):
+        """Run Case 2 numerical examples"""
+        self.examples_output.clear()
+        
+        output = io.StringIO()
+        with redirect_stdout(output):
+            try:
+                numerical_examples = NumericalExamples()
+                numerical_examples.run_case2_examples()
+                self.statusBar().showMessage('Case 2 examples completed')
+            except Exception as e:
+                print(f"Error running Case 2 examples: {e}")
+                self.statusBar().showMessage(f'Error: {e}')
+        
+        self.examples_output.setPlainText(output.getvalue())
+    
+    def run_all_examples(self):
+        """Run all numerical examples"""
+        self.examples_output.clear()
+        
+        output = io.StringIO()
+        with redirect_stdout(output):
+            try:
+                numerical_examples = NumericalExamples()
+                print("=" * 60)
+                print("NUMERICAL EXAMPLES VERIFICATION")
+                print("=" * 60)
+                numerical_examples.run_case1_examples()
+                numerical_examples.run_case2_examples()
+                self.statusBar().showMessage('All examples completed')
+            except Exception as e:
+                print(f"Error running examples: {e}")
+                self.statusBar().showMessage(f'Error: {e}')
+        
+        self.examples_output.setPlainText(output.getvalue())
+
+
+def main():
+    app = QApplication(sys.argv)
+    
+    # Set application style
+    app.setStyle('Fusion')
+    
+    # Create and show the main window
+    window = GradientFieldApp()
+    window.show()
+    
+    # Start the event loop
+    sys.exit(app.exec_())
+
+
+if __name__ == '__main__':
+    main()

constructing_gradient_fields_case_1_and_2_optimized_final.py

@@ -0,0 +1,436 @@
+import sympy as sp
+from abc import ABC, abstractmethod
+from typing import Tuple, Union, Dict, List
+
+class GradientFieldAnalyzer(ABC):
+    """Abstract base class for analyzing gradient fields"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y', real=True)
+        self.X = sp.Matrix([self.x, self.y])
+    
+    @abstractmethod
+    def find_potential(self) -> sp.Expr:
+        pass
+    
+    @abstractmethod
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        pass
+    
+    def verify_potential(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr) -> Tuple[bool, sp.Expr, sp.Expr]:
+        """Verify that phi is indeed a potential function for the vector field"""
+        grad_x = sp.diff(phi, self.x)
+        grad_y = sp.diff(phi, self.y)
+        
+        diff_x = sp.simplify(grad_x - Vx)
+        diff_y = sp.simplify(grad_y - Vy)
+        
+        is_valid = diff_x.equals(0) and diff_y.equals(0)
+        return is_valid, diff_x, diff_y
+    
+    def display_results(self, phi: sp.Expr, Vx: sp.Expr, Vy: sp.Expr):
+        """Display the results in a formatted way"""
+        print(f"Vector Field: F(x,y) = [{Vx}, {Vy}]")
+        print(f"Potential Function: φ(x,y) = {sp.simplify(phi)}")
+        
+        is_valid, diff_x, diff_y = self.verify_potential(phi, Vx, Vy)
+        print(f"Verification: ∇φ = F? {is_valid}")
+        if not is_valid:
+            print(f"  ∂φ/∂x - Vx = {diff_x}")
+            print(f"  ∂φ/∂y - Vy = {diff_y}")
+        print("-" * 50)
+
+
+class ConstantComponentField(GradientFieldAnalyzer):
+    """Case 1: One component is constant"""
+    
+    def __init__(self, constant_component: str = 'x', constant_value: sp.Symbol = None):
+        super().__init__()
+        self.constant_component = constant_component.lower()
+        self.c = constant_value if constant_value else sp.Symbol('c', real=True)
+        
+        # Define unknown functions
+        self.F_x = sp.Function('F_x')(self.x)
+        self.F_y = sp.Function('F_y')(self.y)
+    
+    def find_potential(self) -> sp.Expr:
+        if self.constant_component == 'x':
+            # F(x,y) = [c, F_y(y)]
+            phi = self.c * self.x + sp.Integral(self.F_y, self.y)
+        else:  # constant y-component
+            # F(x,y) = [F_x(x), c]
+            phi = self.c * self.y + sp.Integral(self.F_x, self.x)
+        
+        return phi
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        if self.constant_component == 'x':
+            return self.c, self.F_y
+        else:
+            return self.F_x, self.c
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific vector field (not symbolic)"""
+        # Check which component is constant
+        Vx_free_symbols = Vx.free_symbols if hasattr(Vx, 'free_symbols') else set()
+        Vy_free_symbols = Vy.free_symbols if hasattr(Vy, 'free_symbols') else set()
+        
+        Vx_depends_on_x = self.x in Vx_free_symbols
+        Vx_depends_on_y = self.y in Vx_free_symbols
+        Vy_depends_on_x = self.x in Vy_free_symbols
+        Vy_depends_on_y = self.y in Vy_free_symbols
+        
+        if not Vx_depends_on_x and not Vx_depends_on_y:  # Vx is constant
+            # F(x,y) = [constant, Vy]
+            phi = Vx * self.x + sp.integrate(Vy, self.y)
+        elif not Vy_depends_on_x and not Vy_depends_on_y:  # Vy is constant
+            # F(x,y) = [Vx, constant]
+            phi = Vy * self.y + sp.integrate(Vx, self.x)
+        else:
+            raise ValueError("One component must be constant (independent of both x and y)")
+        return sp.simplify(phi)
+    
+    def get_specific_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases with actual functions"""
+        cases = {}
+        
+        # Case 1a: Constant x-component with specific F_y
+        F_y_specific = self.y**2  # Example: F_y(y) = y²
+        Vx1 = 2  # Use a numeric constant instead of symbolic c
+        Vy1 = F_y_specific
+        phi1 = self.find_potential_for_specific_field(Vx1, Vy1)
+        cases['constant_x_component'] = (Vx1, Vy1, phi1)
+        
+        # Case 1b: Constant y-component with specific F_x
+        F_x_specific = sp.sin(self.x)  # Example: F_x(x) = sin(x)
+        Vx2 = F_x_specific
+        Vy2 = 3  # Use a numeric constant instead of symbolic c
+        phi2 = self.find_potential_for_specific_field(Vx2, Vy2)
+        cases['constant_y_component'] = (Vx2, Vy2, phi2)
+        
+        return cases
+
+
+class LinearComponentField(GradientFieldAnalyzer):
+    """Case 2: Both components are linear functions"""
+    
+    def __init__(self):
+        super().__init__()
+        # Define constants for linear functions
+        self.a1, self.b1, self.c1 = sp.symbols('a1 b1 c1', real=True)
+        self.a2, self.b2, self.c2 = sp.symbols('a2 b2 c2', real=True)
+    
+    def find_potential(self, Vx: sp.Expr = None, Vy: sp.Expr = None) -> sp.Expr:
+        """Find potential function for given linear vector field"""
+        if Vx is None or Vy is None:
+            Vx, Vy = self.get_general_linear_field()
+        
+        # Use the robust method
+        phi = self._find_potential_robust(Vx, Vy)
+        return phi
+    
+    def _find_potential_robust(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Robust implementation that properly checks gradient condition"""
+        # First check if it's a gradient field
+        if not self.check_gradient_condition_for_specific(Vx, Vy):
+            raise ValueError("Field is not a gradient field - cannot find potential")
+        
+        # Method: Integrate Vx with respect to x
+        phi_x = sp.integrate(Vx, self.x)
+        
+        # Differentiate with respect to y and compare with Vy
+        diff_phi_x_y = sp.diff(phi_x, self.y)
+        remaining = Vy - diff_phi_x_y
+        
+        # CRITICAL: Check if remaining depends only on y
+        remaining_free_symbols = remaining.free_symbols if hasattr(remaining, 'free_symbols') else set()
+        if self.x in remaining_free_symbols:
+            raise ValueError(f"Field is not a gradient field - remaining term depends on x: {remaining}")
+        
+        # Integrate remaining with respect to y
+        phi_y = sp.integrate(remaining, self.y)
+        
+        # Combine results
+        phi = phi_x + phi_y
+        
+        return sp.simplify(phi)
+    
+    def get_vector_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        return self.get_general_linear_field()
+    
+    def get_general_linear_field(self) -> Tuple[sp.Expr, sp.Expr]:
+        """General linear vector field: F(x,y) = [a1*x + b1*y + c1, a2*x + b2*y + c2]"""
+        Vx = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy = self.a2 * self.x + self.b2 * self.y + self.c2
+        return Vx, Vy
+    
+    def get_gradient_condition(self) -> sp.Expr:
+        """Return the condition for the field to be a gradient field"""
+        # For a 2D field F = [P, Q] to be a gradient field, we need ∂P/∂y = ∂Q/∂x
+        Vx, Vy = self.get_general_linear_field()
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition)
+    
+    def find_potential_for_specific_field(self, Vx: sp.Expr, Vy: sp.Expr) -> sp.Expr:
+        """Find potential for a specific numeric vector field using robust integration"""
+        return self._find_potential_robust(Vx, Vy)
+    
+    def get_specific_gradient_cases(self) -> Dict[str, Tuple[sp.Expr, sp.Expr, sp.Expr]]:
+        """Return specific cases where the field is a gradient field"""
+        cases = {}
+        
+        # Case 2a: a2 = b1 (from the case study) - FORM 1
+        Vx1 = self.a1 * self.x + self.b1 * self.y + self.c1
+        Vy1 = self.b1 * self.x + self.b2 * self.y + self.c2  # a2 = b1
+        phi1 = self._find_potential_robust(Vx1, Vy1)
+        cases['symmetric_case_1'] = (Vx1, Vy1, phi1)
+        
+        # Case 2b: b2 = a1 (alternative symmetric case) - FORM 2  
+        Vx2 = self.a2 * self.x + self.a1 * self.y + self.c2  # swapped coefficients
+        Vy2 = self.a1 * self.x + self.b1 * self.y + self.c1  # b2 = a1
+        phi2 = self._find_potential_robust(Vx2, Vy2)
+        cases['symmetric_case_2'] = (Vx2, Vy2, phi2)
+        
+        return cases
+    
+    def check_gradient_condition_for_specific(self, Vx: sp.Expr, Vy: sp.Expr) -> bool:
+        """Check if a specific vector field satisfies the gradient condition"""
+        condition = sp.diff(Vx, self.y) - sp.diff(Vy, self.x)
+        return sp.simplify(condition).equals(0)
+    
+    def demonstrate_case_study_forms(self):
+        """Demonstrate the exact forms from the case study"""
+        print("\nEXACT FORMS FROM CASE STUDY:")
+        print("=" * 50)
+        
+        # Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)
+        print("Form 1 (Equation 3.44):")
+        phi_form1 = self.a1 * self.x**2 / 2 + self.b2 * self.y**2 / 2 + self.c2 * self.y + self.x * (self.b1 * self.y + self.c1)
+        print(f"φ(x,y) = {phi_form1}")
+        
+        Vx_form1 = sp.diff(phi_form1, self.x)
+        Vy_form1 = sp.diff(phi_form1, self.y)
+        print(f"F(x,y) = ∇φ = [{Vx_form1}, {Vy_form1}]")
+        matches_form1 = Vx_form1.equals(self.a1*self.x + self.b1*self.y + self.c1) and Vy_form1.equals(self.b1*self.x + self.b2*self.y + self.c2)
+        print(f"Matches Form 1 from case study: {matches_form1}")
+        print()
+        
+        # Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)
+        print("Form 2 (Equation 3.44):")
+        phi_form2 = self.a2 * self.x**2 / 2 + self.b1 * self.y**2 / 2 + self.c1 * self.y + self.x * (self.a1 * self.y + self.c2)
+        print(f"φ(x,y) = {phi_form2}")
+        
+        Vx_form2 = sp.diff(phi_form2, self.x)
+        Vy_form2 = sp.diff(phi_form2, self.y)
+        print(f"F(x,y) = ∇φ = [{Vx_form2}, {Vy_form2}]")
+        matches_form2 = Vx_form2.equals(self.a2*self.x + self.a1*self.y + self.c2) and Vy_form2.equals(self.a1*self.x + self.b1*self.y + self.c1)
+        print(f"Matches Form 2 from case study: {matches_form2}")
+        print()
+
+
+class GradientFieldFactory:
+    """Factory class to create different types of gradient fields"""
+    
+    @staticmethod
+    def create_constant_component_field(component: str = 'x', constant: sp.Symbol = None):
+        return ConstantComponentField(component, constant)
+    
+    @staticmethod
+    def create_linear_component_field():
+        return LinearComponentField()
+    
+    @staticmethod
+    def analyze_all_cases():
+        """Analyze all cases from the case study"""
+        print("=" * 60)
+        print("GRADIENT FIELD CASE STUDY ANALYSIS")
+        print("=" * 60)
+        
+        # Case 1: Constant component
+        print("\nCASE 1: One Component is Constant")
+        print("-" * 40)
+        
+        case1_x = GradientFieldFactory.create_constant_component_field('x')
+        phi1 = case1_x.find_potential()
+        Vx1, Vy1 = case1_x.get_vector_field()
+        case1_x.display_results(phi1, Vx1, Vy1)
+        
+        case1_y = GradientFieldFactory.create_constant_component_field('y')
+        phi2 = case1_y.find_potential()
+        Vx2, Vy2 = case1_y.get_vector_field()
+        case1_y.display_results(phi2, Vx2, Vy2)
+        
+        # Show specific examples
+        print("\nSpecific Examples for Case 1:")
+        examples1 = case1_x.get_specific_cases()
+        for case_name, (Vx, Vy, phi) in examples1.items():
+            print(f"{case_name}:")
+            case1_x.display_results(phi, Vx, Vy)
+        
+        # Case 2: Linear components
+        print("\nCASE 2: Both Components are Linear")
+        print("-" * 40)
+        
+        case2 = GradientFieldFactory.create_linear_component_field()
+        
+        # Show gradient condition
+        condition = case2.get_gradient_condition()
+        print(f"Gradient Field Condition: ∂P/∂y = ∂Q/∂x → {condition} = 0")
+        print(f"This means: a2 = b1 for the general linear field")
+        
+        # Show specific gradient cases
+        print("\nSpecific Gradient Cases for Case 2:")
+        examples2 = case2.get_specific_gradient_cases()
+        for case_name, (Vx, Vy, phi) in examples2.items():
+            print(f"{case_name}:")
+            case2.display_results(phi, Vx, Vy)
+        
+        # Demonstrate the exact forms from the case study
+        case2.demonstrate_case_study_forms()
+        
+        return case1_x, case1_y, case2
+
+
+class NumericalExamples:
+    """Class to demonstrate and verify numerical examples"""
+    
+    def __init__(self):
+        self.x, self.y = sp.symbols('x y')
+        self.constant_analyzer = ConstantComponentField()
+        self.linear_analyzer = LinearComponentField()
+    
+    def run_case1_examples(self):
+        """Run numerical examples for Case 1"""
+        print("\nNumerical Examples - Case 1:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2, 3y²]
+        print("Example 1: F(x,y) = [2, 3y²]")
+        Vx1 = 2
+        Vy1 = 3 * self.y**2
+        phi1 = self.constant_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+        self.constant_analyzer.display_results(phi1, Vx1, Vy1)
+        
+        # Example 2: F(x,y) = [sin(x), 5]
+        print("Example 2: F(x,y) = [sin(x), 5]")
+        Vx2 = sp.sin(self.x)
+        Vy2 = 5
+        phi2 = self.constant_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+        self.constant_analyzer.display_results(phi2, Vx2, Vy2)
+    
+    def run_case2_examples(self):
+        """Run numerical examples for Case 2"""
+        print("\nNumerical Examples - Case 2:")
+        print("-" * 40)
+        
+        # Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2] where a2 = b1 = 3
+        print("Example 1: F(x,y) = [2x + 3y + 1, 3x + 4y + 2]")
+        Vx1 = 2*self.x + 3*self.y + 1
+        Vy1 = 3*self.x + 4*self.y + 2
+        
+        # Check if it's a gradient field first
+        is_gradient = self.linear_analyzer.check_gradient_condition_for_specific(Vx1, Vy1)
+        print(f"Is this a gradient field? {is_gradient}")
+        
+        if is_gradient:
+            phi1 = self.linear_analyzer.find_potential_for_specific_field(Vx1, Vy1)
+            self.linear_analyzer.display_results(phi1, Vx1, Vy1)
+            
+            # Show that this matches Form 1 from the case study
+            print("This matches Form 1 from case study with:")
+            print("  a1 = 2, b1 = 3, c1 = 1")
+            print("  a2 = 3, b2 = 4, c2 = 2")
+            phi_form1 = 2*self.x**2/2 + 4*self.y**2/2 + 2*self.y + self.x*(3*self.y + 1)
+            print(f"  φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+            print(f"        = {sp.simplify(phi_form1)}")
+        else:
+            print("This field cannot have a potential function!")
+        print("-" * 50)
+        
+        # Example 2: F(x,y) = [x + 2y, 2x + 3y] where a2 = b1 = 2
+        print("Example 2: F(x,y) = [x + 2y, 2x + 3y]")
+        Vx2 = self.x + 2*self.y
+        Vy2 = 2*self.x + 3*self.y
+        
+        is_gradient2 = self.linear_analyzer.check_gradient_condition_for_specific(Vx2, Vy2)
+        print(f"Is this a gradient field? {is_gradient2}")
+        
+        if is_gradient2:
+            phi2 = self.linear_analyzer.find_potential_for_specific_field(Vx2, Vy2)
+            self.linear_analyzer.display_results(phi2, Vx2, Vy2)
+        else:
+            print("This field cannot have a potential function!")
+        print("-" * 50)
+        
+        # Example 3: Non-gradient field (should fail)
+        print("Example 3: Non-gradient field F(x,y) = [x + y, 2x + y]")
+        Vx3 = self.x + self.y
+        Vy3 = 2*self.x + self.y
+        
+        is_gradient3 = self.linear_analyzer.check_gradient_condition_for_specific(Vx3, Vy3)
+        print(f"Is this a gradient field? {is_gradient3}")
+        
+        if is_gradient3:
+            print("ERROR: This should not be a gradient field!")
+            print("Let's check the gradient condition:")
+            print(f"  ∂P/∂y = {sp.diff(Vx3, self.y)}")
+            print(f"  ∂Q/∂x = {sp.diff(Vy3, self.x)}")
+            print(f"  Gradient condition satisfied? {sp.diff(Vx3, self.y).equals(sp.diff(Vy3, self.x))}")
+        else:
+            print("✓ Correct: This field cannot have a potential function!")
+            print(f"Reason: ∂P/∂y = {sp.diff(Vx3, self.y)} ≠ ∂Q/∂x = {sp.diff(Vy3, self.x)}")
+            print("The gradient condition a₂ = b₁ is not satisfied")
+            
+            # Test our robust integration method
+            print("\nTesting robust integration method:")
+            try:
+                phi3 = self.linear_analyzer.find_potential_for_specific_field(Vx3, Vy3)
+                print(f"Unexpected success: φ(x,y) = {phi3}")
+            except ValueError as e:
+                print(f"✓ Robust method correctly failed: {e}")
+        print("-" * 50)
+
+
+def main():
+    # Run the complete analysis
+    analyzer1, analyzer2, analyzer3 = GradientFieldFactory.analyze_all_cases()
+    
+    # Run numerical examples
+    print("\n" + "=" * 60)
+    print("NUMERICAL EXAMPLES VERIFICATION")
+    print("=" * 60)
+    
+    numerical_examples = NumericalExamples()
+    numerical_examples.run_case1_examples()
+    numerical_examples.run_case2_examples()
+    
+    # Final summary
+    print("\n" + "=" * 60)
+    print("FINAL SUMMARY: CONSTRUCTING GRADIENT FIELDS")
+    print("=" * 60)
+    
+    print("\n✓ CASE 1: One Component Constant")
+    print("  • Always a gradient field")
+    print("  • Potential: φ(x,y) = c·x + ∫Fᵧ(y)dy  OR  φ(x,y) = c·y + ∫Fₓ(x)dx")
+    
+    print("\n✓ CASE 2: Both Components Linear")
+    print("  • Gradient field IF AND ONLY IF a₂ = b₁")
+    print("  • Potential forms:")
+    print("    Form 1: φ(x,y) = a₁x²/2 + b₂y²/2 + c₂y + x(b₁y + c₁)")
+    print("    Form 2: φ(x,y) = a₂x²/2 + b₁y²/2 + c₁y + x(a₁y + c₂)")
+    
+    print("\n✓ KEY MATHEMATICAL INSIGHTS:")
+    print("  • Gradient condition: ∂P/∂y = ∂Q/∂x")
+    print("  • For linear fields: a₂ = b₁")
+    print("  • Robust integration method prevents false positives")
+    print("  • Matches case study equations (3.44) and (3.45)")
+    
+    print("\n✓ OBJECT-ORIENTED DESIGN:")
+    print("  • Abstract base class for extensibility")
+    print("  • Factory pattern for creating analyzers")
+    print("  • Robust verification and error handling")
+    print("  • Clear separation of symbolic and numerical analysis")
+
+
+if __name__ == "__main__":
+    main()

output.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5f83877946e2d1de9ab20ec56f24cec366a311a81e80dfdc63dfdb9d4a0e13c8
+size 11969088

requirements.txt

@@ -0,0 +1 @@
+PyQt5