Update app.py

app.py

@@ -2,44 +2,68 @@ import gradio as gr
 import PyPDF2
 import re
 import json
-import io
 from typing import Dict, List, Tuple, Any
 import traceback
 
-class PropertyFormulaAnalyzer:
+class SemanticFormulaAnalyzer:
     def __init__(self, formula_file_path: str = "formulas.txt"):
-        """Initialize the analyzer with the formula file path"""
+        """Initialize the analyzer with the semantic formula file"""
         self.formula_file_path = formula_file_path
         self.formulas = {}
-        self.computed_values = {}  # Store computed values for cascading calculations
+        self.computed_values = {}
         self.load_formulas()
     
     def load_formulas(self):
-        """Load and parse all formulas from the formula file"""
+        """Load semantic formulas from file"""
         try:
             with open(self.formula_file_path, 'r', encoding='utf-8') as f:
                 content = f.read()
             
-            # Parse formulas using regex
-            pattern = r'(\d+)\.\s+([A-Z]+\d+)\s*\(([^)]+)\)\s*=\s*([^=\n]+?)(?=\s+\d+\.|$)'
-            matches = re.findall(pattern, content, re.DOTALL)
+            # Parse semantic formulas: Variable_Name = formula
+            # Pattern: capture variable name, formula, and description
+            lines = content.split('\n')
             
-            for match in matches:
-                formula_num, cell_ref, description, formula = match
-                formula = formula.strip()
-                formula = re.sub(r'\s+', ' ', formula)
+            current_formula_name = None
+            current_formula = None
+            current_description = None
+            
+            for line in lines:
+                line = line.strip()
+                
+                # Skip empty lines and section headers
+                if not line or line.startswith('#'):
+                    continue
+                
+                # Check if line contains a formula assignment
+                if '=' in line and not line.startswith('#'):
+                    # Save previous formula if exists
+                    if current_formula_name and current_formula:
+                        self.formulas[current_formula_name] = {
+                            'formula': current_formula,
+                            'description': current_description or current_formula_name
+                        }
+                    
+                    # Parse new formula
+                    parts = line.split('=', 1)
+                    current_formula_name = parts[0].strip()
+                    current_formula = parts[1].strip()
+                    current_description = None
                 
-                self.formulas[cell_ref] = {
-                    'number': formula_num,
-                    'description': description.strip(),
-                    'formula': formula,
-                    'cell_ref': cell_ref
+                # Check if line is a description comment
+                elif line.startswith('# Description:'):
+                    current_description = line.replace('# Description:', '').strip()
+            
+            # Add last formula
+            if current_formula_name and current_formula:
+                self.formulas[current_formula_name] = {
+                    'formula': current_formula,
+                    'description': current_description or current_formula_name
                 }
             
-            print(f"Loaded {len(self.formulas)} formulas from {self.formula_file_path}")
+            print(f"✅ Loaded {len(self.formulas)} semantic formulas")
             
         except Exception as e:
-            print(f"Error loading formulas: {str(e)}")
+            print(f"❌ Error loading formulas: {str(e)}")
             traceback.print_exc()
     
     def extract_text_from_pdf(self, file_path: str) -> str:
@@ -65,7 +89,7 @@ class PropertyFormulaAnalyzer:
             return ""
     
     def extract_data_from_files(self, files: List[str]) -> Dict[str, Any]:
-        """Extract all relevant data from uploaded property files"""
+        """Extract data with semantic variable names"""
         combined_text = ""
         
         for file_path in files:
@@ -76,34 +100,74 @@ class PropertyFormulaAnalyzer:
         
         extracted_data = {}
         
-        # Define extraction patterns
+        # Comprehensive extraction patterns with semantic names
         patterns = {
-            'UNITS': [r'(?:Total\s+)?Units?\s*:?\s*(\d+)', r'Units\s*(\d+)'],
-            'BUILDING_SF': [r'Building\s+(?:Size|SF)\s*:?\s*([\d,]+)', r'Building\s+(?:Size|SF)\s*(\d+)'],
-            'LOT_ACRES': [r'Lot\s+Size\s*:?\s*([\d.]+)\s*(?:acres?|Acres?)', r'Lot:\s*([\d.]+)\s*acres?'],
-            'PRICE': [r'(?:Asking\s+)?Price\s*:?\s*\$\s*([\d,]+)', r'Price\s+per\s+Unit\s*\$\s*([\d,]+)'],
-            'NOI': [r'Net\s+Operating\s+Income\s*(?:\(NOI\))?\s*:?\s*\$?\s*([\d,]+)', r'NOI\s*:?\s*\$?\s*([\d,]+)'],
-            'EGI': [r'Effective\s+Gross\s+Income\s*:?\s*\$?\s*([\d,]+)', r'EGI\s*:?\s*\$?\s*([\d,]+)'],
-            'GPR': [r'Gross\s+Potential\s+Rent\s*(?:\(Annual\))?\s*:?\s*\$?\s*([\d,]+)', r'GPR\s*:?\s*\$?\s*([\d,]+)'],
-            'OPEX': [r'Operating\s+Expenses\s*:?\s*\$?\s*([\d,]+)', r'Total\s+Operating\s+Expenses\s*=?\s*\$?\s*([\d,]+)'],
+            # Basic Property Info
+            'UNITS': [r'(?:Total\s+)?Units?\s*:?\s*(\d+)', r'(\d+)\s*units?'],
+            'GROSS_SF': [r'Building\s+(?:Size|SF)\s*:?\s*([\d,]+)', r'Building\s+SF\s*(\d+)', r'(\d+)\s*SF'],
+            'BUILDING_SF': [r'Building\s+(?:Size|SF)\s*:?\s*([\d,]+)'],
+            'RENTABLE_SF': [r'Rentable\s+SF\s*:?\s*([\d,]+)', r'RSF\s*:?\s*([\d,]+)'],
+            'LOT_ACRES': [r'Lot\s+Size\s*:?\s*([\d.]+)\s*(?:acres?|Acres?)'],
+            'LOT_SF': [r'Lot\s+(?:Size\s+)?SF\s*:?\s*([\d,]+)'],
+            
+            # Financial - Core
+            'PRICE': [r'(?:Asking\s+)?Price\s*:?\s*\$\s*([\d,]+)', r'Purchase\s+Price\s*:?\s*\$\s*([\d,]+)'],
+            'NOI': [r'Net\s+Operating\s+Income\s*(?:\(NOI\))?\s*:?\s*\$?\s*([\d,]+)'],
+            'NET_OPERATING_INCOME': [r'Net\s+Operating\s+Income\s*(?:\(NOI\))?\s*:?\s*\$?\s*([\d,]+)'],
+            'EGI': [r'Effective\s+Gross\s+Income\s*:?\s*\$?\s*([\d,]+)'],
+            'EFFECTIVE_GROSS_INCOME': [r'Effective\s+Gross\s+Income\s*:?\s*\$?\s*([\d,]+)'],
+            'GPR': [r'Gross\s+Potential\s+Rent\s*(?:\(Annual\))?\s*:?\s*\$?\s*([\d,]+)'],
+            'GROSS_POTENTIAL_RENT': [r'Gross\s+Potential\s+Rent\s*:?\s*\$?\s*([\d,]+)'],
             'VACANCY': [r'Vacancy\s*(?:\([\d.]+%\))?\s*:?\s*-?\$?\s*([\d,]+)'],
+            'VACANCY_LOSS': [r'Vacancy\s*(?:\([\d.]+%\))?\s*:?\s*-?\$?\s*([\d,]+)'],
+            'VACANCY_RATE': [r'Vacancy\s*(?:\()?([\d.]+)%'],
+            
+            # Operating Expenses
+            'OPEX': [r'Operating\s+Expenses\s*:?\s*\$?\s*([\d,]+)', r'Total\s+Operating\s+Expenses\s*=?\s*\$?\s*([\d,]+)'],
+            'TOTAL_OPERATING_EXPENSES': [r'Total\s+Operating\s+Expenses\s*=?\s*\$?\s*([\d,]+)'],
             'PROPERTY_TAXES': [r'Property\s+Taxes\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
+            'REAL_ESTATE_TAXES': [r'Property\s+Taxes\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
             'INSURANCE': [r'Insurance\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
             'UTILITIES': [r'Utilities\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
-            'REPAIRS_MAINTENANCE': [r'Repairs?\s*(?:&|and)?\s*Maintenance\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
+            'REPAIRS_AND_MAINTENANCE': [r'Repairs?\s*(?:&|and)?\s*Maintenance\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
             'PAYROLL': [r'Payroll\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
             'ADMINISTRATIVE': [r'Administrative\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
             'MARKETING': [r'Marketing\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
+            'ADVERTISING_AND_MARKETING_COST': [r'Marketing\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
             'REPLACEMENT_RESERVES': [r'Replacement\s+Reserves\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
             'MANAGEMENT_FEE': [r'Management\s*(?:\([^)]+\))?\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
-            'CAP_RATE': [r'Cap\s+Rate\s*:?\s*([\d.]+)%?', r'Cap\s+Rate\s+([\d.]+)'],
+            'MANAGEMENT_FEE_PERCENTAGE': [r'Management\s*.*?(\d+)%', r'Management\s*@\s*([\d.]+)%'],
+            'PROFESSIONAL_FEES': [r'Professional\s+Fees\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
+            
+            # Rates and Percentages
+            'CAP_RATE': [r'Cap\s+Rate\s*:?\s*([\d.]+)%?'],
             'INTEREST_RATE': [r'Interest\s+Rate\s*:?\s*([\d.]+)%?'],
+            'INTEREST_RATE_DECIMAL': [r'Interest\s+Rate\s*:?\s*([\d.]+)%?'],
             'LTC': [r'Loan[- ]to[- ]Cost\s*(?:\(LTC\))?\s*:?\s*([\d.]+)%?'],
+            'LTC_RATIO': [r'Loan[- ]to[- ]Cost\s*(?:\(LTC\))?\s*:?\s*([\d.]+)%?'],
             'EXIT_CAP_RATE': [r'Exit\s+Cap\s+Rate\s*:?\s*([\d.]+)%?'],
+            'EXIT_CAP_RATE_DECIMAL': [r'Exit\s+Cap\s+Rate\s*:?\s*([\d.]+)%?'],
+            
+            # Demographics
             'MEDIAN_INCOME': [r'Median\s+(?:HH\s+)?Income\s*:?\s*\$?\s*([\d,]+)'],
             'POPULATION': [r'Population\s*:?\s*([\d,]+)'],
             'HOUSEHOLDS': [r'Households\s*:?\s*([\d,]+)'],
             'RENTER_OCCUPIED_PCT': [r'Renter[- ]Occupied\s*:?\s*([\d.]+)%?'],
+            
+            # Construction & Development
+            'CONSTRUCTION_COST_PER_GSF': [r'Construction\s+Cost\s*:?\s*\$?\s*([\d,]+)\s*per\s+(?:GSF|SF)'],
+            'TOTAL_CONSTRUCTION_GMP': [r'(?:Total\s+)?Construction\s+GMP\s*:?\s*\$?\s*([\d,]+)'],
+            'SOFT_COSTS': [r'(?:Total\s+)?Soft\s+Costs?\s*:?\s*\$?\s*([\d,]+)'],
+            'TOTAL_SOFT_COST': [r'(?:Total\s+)?Soft\s+Costs?\s*:?\s*\$?\s*([\d,]+)'],
+            'CONTINGENCY': [r'Contingency\s*:?\s*\$?\s*([\d,]+)'],
+            'CONTINGENCY_COST': [r'Contingency\s*:?\s*\$?\s*([\d,]+)'],
+            'DEV_FEE': [r'Dev(?:elopment)?\s+Fee\s*:?\s*\$?\s*([\d,]+)'],
+            'DEVELOPMENT_FEE': [r'Dev(?:elopment)?\s+Fee\s*:?\s*\$?\s*([\d,]+)'],
+            
+            # Land & Acquisition
+            'LAND_VALUE': [r'(?:Total\s+)?Land\s+Value\s*:?\s*\$?\s*([\d,]+)'],
+            'CLOSING_COSTS': [r'Closing\s+Costs\s*:?\s*\$?\s*([\d,]+)'],
+            'ACQUISITION_FEE': [r'Acq(?:uisition)?\s+Fee\s*:?\s*\$?\s*([\d,]+)'],
         }
         
         for key, pattern_list in patterns.items():
@@ -118,138 +182,127 @@ class PropertyFormulaAnalyzer:
                     except (ValueError, IndexError):
                         continue
         
-        # Derived values
-        if 'PRICE' in extracted_data and 'UNITS' in extracted_data:
-            extracted_data['PRICE_PER_UNIT'] = extracted_data['PRICE'] / extracted_data['UNITS']
+        # Post-processing: Handle percentages and derived values
+        if 'INTEREST_RATE' in extracted_data:
+            if extracted_data['INTEREST_RATE'] > 1:
+                extracted_data['INTEREST_RATE'] = extracted_data['INTEREST_RATE'] / 100
+            extracted_data['INTEREST_RATE_DECIMAL'] = extracted_data['INTEREST_RATE']
         
-        if 'NOI' in extracted_data and 'PRICE' in extracted_data:
-            extracted_data['CALCULATED_CAP_RATE'] = (extracted_data['NOI'] / extracted_data['PRICE']) * 100
+        if 'LTC' in extracted_data:
+            if extracted_data['LTC'] > 1:
+                extracted_data['LTC'] = extracted_data['LTC'] / 100
+            extracted_data['LTC_RATIO'] = extracted_data['LTC']
         
-        if 'LTC' in extracted_data and extracted_data['LTC'] > 1:
-            extracted_data['LTC'] = extracted_data['LTC'] / 100
+        if 'CAP_RATE' in extracted_data and extracted_data['CAP_RATE'] < 1:
+            extracted_data['CAP_RATE'] = extracted_data['CAP_RATE'] * 100
         
-        if 'INTEREST_RATE' in extracted_data and extracted_data['INTEREST_RATE'] > 1:
-            extracted_data['INTEREST_RATE'] = extracted_data['INTEREST_RATE'] / 100
+        if 'EXIT_CAP_RATE' in extracted_data:
+            if extracted_data['EXIT_CAP_RATE'] > 1:
+                extracted_data['EXIT_CAP_RATE_DECIMAL'] = extracted_data['EXIT_CAP_RATE'] / 100
+            else:
+                extracted_data['EXIT_CAP_RATE_DECIMAL'] = extracted_data['EXIT_CAP_RATE']
         
-        # Map to cell references
-        if 'BUILDING_SF' in extracted_data:
-            extracted_data['D2'] = extracted_data['BUILDING_SF']
+        if 'VACANCY_RATE' in extracted_data and extracted_data['VACANCY_RATE'] > 1:
+            extracted_data['VACANCY_RATE'] = extracted_data['VACANCY_RATE'] / 100
         
-        if 'UNITS' in extracted_data:
-            extracted_data['F2'] = extracted_data['UNITS']
+        # Map synonyms
+        if 'BUILDING_SF' in extracted_data and 'GROSS_SF' not in extracted_data:
+            extracted_data['GROSS_SF'] = extracted_data['BUILDING_SF']
         
-        if 'BUILDING_SF' in extracted_data:
-            extracted_data['E2'] = extracted_data['BUILDING_SF'] * 0.9
+        if 'GROSS_SF' in extracted_data and 'BUILDING_SF' not in extracted_data:
+            extracted_data['BUILDING_SF'] = extracted_data['GROSS_SF']
         
-        if 'OPEX' in extracted_data:
-            extracted_data['M15'] = extracted_data['OPEX']
+        # Estimate RENTABLE_SF if not provided (assume 90% efficiency)
+        if 'GROSS_SF' in extracted_data and 'RENTABLE_SF' not in extracted_data:
+            extracted_data['RENTABLE_SF'] = extracted_data['GROSS_SF'] * 0.9
         
-        if 'EGI' in extracted_data:
-            extracted_data['J38'] = extracted_data['EGI']
+        # Map EGI synonyms
+        if 'EGI' in extracted_data and 'EFFECTIVE_GROSS_INCOME' not in extracted_data:
+            extracted_data['EFFECTIVE_GROSS_INCOME'] = extracted_data['EGI']
         
-        return extracted_data
-    
-    def normalize_cell_ref(self, cell_ref: str) -> str:
-        """Normalize cell reference by removing $ signs"""
-        return cell_ref.replace('$', '')
-    
-    def get_value(self, var: str, data: Dict[str, Any]) -> Any:
-        """Get value for a variable, handling all variants"""
-        # Try exact match
-        if var in data:
-            return data[var]
+        if 'EFFECTIVE_GROSS_INCOME' in extracted_data and 'EGI' not in extracted_data:
+            extracted_data['EGI'] = extracted_data['EFFECTIVE_GROSS_INCOME']
         
-        # Try normalized (without $)
-        normalized = self.normalize_cell_ref(var)
-        if normalized in data:
-            return data[normalized]
+        # Map NOI synonyms
+        if 'NOI' in extracted_data and 'NET_OPERATING_INCOME' not in extracted_data:
+            extracted_data['NET_OPERATING_INCOME'] = extracted_data['NOI']
         
-        # Try with computed values
-        if var in self.computed_values:
-            return self.computed_values[var]
+        if 'NET_OPERATING_INCOME' in extracted_data and 'NOI' not in extracted_data:
+            extracted_data['NOI'] = extracted_data['NET_OPERATING_INCOME']
         
-        if normalized in self.computed_values:
-            return self.computed_values[normalized]
+        # Map OPEX synonyms
+        if 'OPEX' in extracted_data and 'TOTAL_OPERATING_EXPENSES' not in extracted_data:
+            extracted_data['TOTAL_OPERATING_EXPENSES'] = extracted_data['OPEX']
         
-        return None
+        if 'TOTAL_OPERATING_EXPENSES' in extracted_data and 'OPEX' not in extracted_data:
+            extracted_data['OPEX'] = extracted_data['TOTAL_OPERATING_EXPENSES']
+        
+        # Derive management fee percentage if we have the dollar amount
+        if 'MANAGEMENT_FEE' in extracted_data and 'EFFECTIVE_GROSS_INCOME' in extracted_data and 'MANAGEMENT_FEE_PERCENTAGE' not in extracted_data:
+            extracted_data['MANAGEMENT_FEE_PERCENTAGE'] = extracted_data['MANAGEMENT_FEE'] / extracted_data['EFFECTIVE_GROSS_INCOME']
+        
+        return extracted_data
     
     def extract_variables_from_formula(self, formula: str) -> List[str]:
-        """Extract all variable references from a formula"""
-        # Match Excel-style cell references (e.g., C4, $D$2, E2)
-        cell_pattern = r'\$?[A-Z]+\$?\d+'
-        variables = re.findall(cell_pattern, formula)
+        """Extract variable names from formula"""
+        # Match Python-style variable names (letters, numbers, underscores)
+        # But exclude Python keywords and operators
+        var_pattern = r'\b([A-Z][A-Z0-9_]*)\b'
+        variables = re.findall(var_pattern, formula)
         
-        # Remove Excel functions and operators
-        excel_functions = {'SUM', 'PV', 'MIN', 'MAX', 'AVERAGE', 'IF', 'AND', 'OR'}
-        variables = [v for v in variables if v not in excel_functions]
+        # Remove Python built-in functions
+        python_builtins = {'SUM', 'MIN', 'MAX', 'ABS', 'ROUND'}
+        variables = [v for v in variables if v not in python_builtins]
         
         return list(set(variables))
     
     def check_formula_computable(self, formula: str, data: Dict[str, Any]) -> Tuple[bool, List[str]]:
-        """Check if a formula can be computed with available data"""
+        """Check if formula can be computed"""
         variables = self.extract_variables_from_formula(formula)
         missing = []
         
         for var in variables:
-            if self.get_value(var, data) is None:
+            if var not in data and var not in self.computed_values:
                 missing.append(var)
         
         return len(missing) == 0, missing
     
     def safe_eval_formula(self, formula: str, data: Dict[str, Any]) -> Any:
-        """Safely evaluate a formula with the provided data"""
+        """Safely evaluate a semantic formula"""
         try:
-            formula_py = formula
-            
-            # Handle SUM function with ranges
-            def process_sum_range(match):
-                range_str = match.group(1)
-                if ':' in range_str:
-                    # For now, return 0 for ranges we can't process
-                    return '0'
-                else:
-                    # Individual cells
-                    cells = [c.strip() for c in range_str.split(',')]
-                    values = []
-                    for cell in cells:
-                        val = self.get_value(cell, data)
-                        if val is not None:
-                            values.append(str(val))
-                    if values:
-                        return f"({'+'.join(values)})"
-                    return '0'
-            
-            sum_pattern = r'SUM\(([^)]+)\)'
-            formula_py = re.sub(sum_pattern, process_sum_range, formula_py)
-            
-            # Handle PV function - simplified to 0
-            formula_py = re.sub(r'PV\([^)]+\)', '0', formula_py)
-            
-            # Handle MIN function
-            formula_py = re.sub(r'MIN\(([^)]+)\)', r'min([\1])', formula_py)
-            
-            # Replace cell references with their values
-            variables = self.extract_variables_from_formula(formula_py)
+            # Combine extracted data with computed values
+            all_data = {**data, **self.computed_values}
+            
+            # Replace variables with their values
+            formula_eval = formula
+            variables = self.extract_variables_from_formula(formula)
+            
             for var in sorted(variables, key=len, reverse=True):
-                value = self.get_value(var, data)
-                if value is not None:
-                    formula_py = formula_py.replace(var, str(value))
+                if var in all_data:
+                    value = all_data[var]
+                    formula_eval = re.sub(r'\b' + var + r'\b', str(value), formula_eval)
             
-            # Replace ^ with ** for exponentiation
-            formula_py = formula_py.replace('^', '**')
+            # Replace ** with ** (already correct for Python)
+            # Handle any remaining math operations
+            formula_eval = formula_eval.replace('^', '**')
             
-            # Clean up any remaining issues
-            formula_py = formula_py.replace('--', '+')
+            # Evaluate safely
+            safe_dict = {
+                'min': min,
+                'max': max,
+                'sum': sum,
+                'abs': abs,
+                'round': round
+            }
             
-            # Evaluate
-            result = eval(formula_py, {"__builtins__": {"min": min, "max": max, "sum": sum}}, {})
+            result = eval(formula_eval, {"__builtins__": safe_dict}, {})
             return result
             
         except Exception as e:
-            raise Exception(f"Error evaluating formula '{formula}': {str(e)}")
+            raise Exception(f"Evaluation error: {str(e)}")
     
     def process_files(self, files) -> Tuple[str, str, str]:
-        """Main processing function for Gradio interface"""
+        """Main processing function"""
         try:
             if not files:
                 return "❌ No files uploaded", "", ""
@@ -265,22 +318,20 @@ class PropertyFormulaAnalyzer:
             # Reset computed values
             self.computed_values = {}
             
-            # Multiple passes to handle dependencies
-            max_iterations = 5
+            # Multiple passes for dependency resolution
+            max_iterations = 10
             computable_formulas = {}
             non_computable_formulas = {}
             
             for iteration in range(max_iterations):
                 newly_computed = 0
                 
-                for cell_ref, formula_info in self.formulas.items():
+                for formula_name, formula_info in self.formulas.items():
                     # Skip if already computed
-                    if cell_ref in computable_formulas:
+                    if formula_name in computable_formulas:
                         continue
                     
                     formula = formula_info['formula']
-                    
-                    # Combine extracted data with computed values for checking
                     all_data = {**extracted_data, **self.computed_values}
                     
                     is_computable, missing_vars = self.check_formula_computable(formula, all_data)
@@ -289,8 +340,7 @@ class PropertyFormulaAnalyzer:
                         try:
                             result = self.safe_eval_formula(formula, all_data)
                             
-                            # Store result
-                            computable_formulas[cell_ref] = {
+                            computable_formulas[formula_name] = {
                                 'description': formula_info['description'],
                                 'formula': formula,
                                 'result': result,
@@ -298,35 +348,32 @@ class PropertyFormulaAnalyzer:
                                 'iteration': iteration + 1
                             }
                             
-                            # Add to computed values for cascading
-                            self.computed_values[cell_ref] = result
-                            self.computed_values[self.normalize_cell_ref(cell_ref)] = result
-                            
+                            # Store for cascading
+                            self.computed_values[formula_name] = result
                             newly_computed += 1
                             
                         except Exception as e:
-                            non_computable_formulas[cell_ref] = {
+                            non_computable_formulas[formula_name] = {
                                 'description': formula_info['description'],
                                 'formula': formula,
                                 'error': str(e),
                                 'missing_variables': []
                             }
                     else:
-                        non_computable_formulas[cell_ref] = {
+                        non_computable_formulas[formula_name] = {
                             'description': formula_info['description'],
                             'formula': formula,
                             'missing_variables': missing_vars
                         }
                 
-                print(f"Iteration {iteration + 1}: Computed {newly_computed} new formulas")
+                print(f"📊 Iteration {iteration + 1}: Computed {newly_computed} new formulas (Total: {len(computable_formulas)})")
                 
-                # If no new formulas computed, stop
                 if newly_computed == 0:
                     break
             
-            # Remove successfully computed formulas from non-computable list
-            for cell_ref in computable_formulas.keys():
-                non_computable_formulas.pop(cell_ref, None)
+            # Remove computed formulas from non-computable list
+            for formula_name in computable_formulas.keys():
+                non_computable_formulas.pop(formula_name, None)
             
             # Create summary
             summary = f"""
@@ -338,52 +385,64 @@ class PropertyFormulaAnalyzer:
 **📄 Files Processed:** {len(file_paths)}
 **🔢 Data Points Extracted:** {len(extracted_data)}
 **🔄 Computation Iterations:** {iteration + 1}
+**📈 Success Rate:** {(len(computable_formulas) / len(self.formulas) * 100):.1f}%
 """
             
-            # Create extracted data display
+            # Extracted data display
             data_display = "## 📥 Extracted Property Data\n\n"
             data_display += "| Variable | Value |\n|----------|-------|\n"
             for key, value in sorted(extracted_data.items()):
                 if isinstance(value, float):
-                    data_display += f"| {key} | {value:,.2f} |\n"
+                    data_display += f"| {key} | {value:,.4f} |\n"
                 else:
                     data_display += f"| {key} | {value} |\n"
             
-            # Create results display
+            # Results display
             results_display = "## ✅ Computed Formulas\n\n"
-            for cell_ref, info in sorted(computable_formulas.items()):
-                results_display += f"### {cell_ref}: {info['description']}\n"
-                results_display += f"**Formula:** `{info['formula']}`\n"
-                results_display += f"**Result:** {info['formatted_result']}\n"
-                results_display += f"*Computed in iteration {info['iteration']}*\n\n"
+            
+            # Group by iteration
+            by_iteration = {}
+            for name, info in computable_formulas.items():
+                iter_num = info['iteration']
+                if iter_num not in by_iteration:
+                    by_iteration[iter_num] = []
+                by_iteration[iter_num].append((name, info))
+            
+            for iter_num in sorted(by_iteration.keys()):
+                results_display += f"### Iteration {iter_num} ({len(by_iteration[iter_num])} formulas)\n\n"
+                for name, info in sorted(by_iteration[iter_num]):
+                    results_display += f"**{name}** = {info['formatted_result']}\n"
+                    results_display += f"*{info['description']}*\n"
+                    results_display += f"`{info['formula']}`\n\n"
             
             # if non_computable_formulas:
-            #     results_display += "\n## ❌ Non-Computable Formulas\n\n"
-            #     # Show only first 20 to avoid overwhelming output
-            #     for idx, (cell_ref, info) in enumerate(sorted(non_computable_formulas.items())):
-            #         if idx >= 20:
-            #             results_display += f"\n*... and {len(non_computable_formulas) - 20} more non-computable formulas*\n"
+            #     results_display += f"\n## ❌ Non-Computable Formulas ({len(non_computable_formulas)})\n\n"
+            #     # Show sample of non-computable
+            #     sample_size = min(15, len(non_computable_formulas))
+            #     results_display += f"*Showing {sample_size} of {len(non_computable_formulas)} non-computable formulas*\n\n"
+                
+            #     for idx, (name, info) in enumerate(sorted(non_computable_formulas.items())):
+            #         if idx >= sample_size:
             #             break
-            #         results_display += f"### {cell_ref}: {info['description']}\n"
-            #         results_display += f"**Formula:** `{info['formula']}`\n"
+            #         results_display += f"**{name}**: {info['description']}\n"
             #         if info.get('missing_variables'):
-            #             results_display += f"**Missing Variables:** {', '.join(info['missing_variables'][:5])}\n"
-            #         if info.get('error'):
-            #             results_display += f"**Error:** {info['error']}\n"
+            #             missing = info['missing_variables'][:5]
+            #             results_display += f"Missing: {', '.join(missing)}\n"
             #         results_display += "\n"
             
-            # Create JSON output
+            # JSON output
             json_output = {
                 'summary': {
                     'total_formulas': len(self.formulas),
                     'computable': len(computable_formulas),
                     'non_computable': len(non_computable_formulas),
                     'files_processed': len(file_paths),
-                    'iterations': iteration + 1
+                    'iterations': iteration + 1,
+                    'success_rate': round(len(computable_formulas) / len(self.formulas) * 100, 2)
                 },
                 'extracted_data': extracted_data,
                 'computable_formulas': computable_formulas,
-                'non_computable_formulas': non_computable_formulas
+                'non_computable_formulas': {k: v for k, v in list(non_computable_formulas.items())[:20]}
             }
             
             json_str = json.dumps(json_output, indent=2)
@@ -394,16 +453,21 @@ class PropertyFormulaAnalyzer:
             error_msg = f"❌ Error processing files:\n{str(e)}\n\n{traceback.format_exc()}"
             return error_msg, "", ""
 
-# Initialize the analyzer
-analyzer = PropertyFormulaAnalyzer("formulas.txt")
+# Initialize analyzer
+analyzer = SemanticFormulaAnalyzer("formulas.txt")
 
 # Create Gradio interface
 with gr.Blocks(title="Property Formula Analyzer", theme=gr.themes.Soft()) as app:
     gr.Markdown("""
-    # 🏢 Property Formula Analyzer
+    # 🏢 Property Formula Analyzer - Semantic Edition
+    
+    Upload property documents to extract data and compute real estate formulas using **semantic variable names**.
     
-    Upload property documents (PDF or TXT) to automatically extract data and compute real estate formulas.
-    The system uses iterative computation to handle formula dependencies.
+    ### Features:
+    - 📄 Extracts data from PDFs and text files
+    - 🔢 Matches property metrics to formula variables
+    - 🔄 Multi-pass computation for dependent formulas
+    - 📊 Clear, human-readable formula names
     """)
     
     with gr.Row():
@@ -419,29 +483,26 @@ with gr.Blocks(title="Property Formula Analyzer", theme=gr.themes.Soft()) as app
             
             gr.Markdown("""
             ### 📋 Instructions:
-            1. Upload one or more property documents (PDF or TXT format)
+            1. Upload property documents (Offering Memorandum, Operating Expenses, etc.)
             2. Click "Analyze & Compute Formulas"
-            3. Review the extracted data and computed formulas
-            4. Download the JSON results for further analysis
+            3. Review extracted data and computed metrics
+            4. Download JSON results
             
-            **Note:** The system performs multiple computation passes to handle formula dependencies.
+            **Example Variables**: `UNITS`, `PRICE`, `NOI`, `GROSS_SF`, `EFFECTIVE_GROSS_INCOME`
             """)
     
     with gr.Row():
-        with gr.Column():
-            summary_output = gr.Markdown(label="Summary")
+        summary_output = gr.Markdown(label="Summary")
     
     with gr.Row():
-        with gr.Column():
-            results_output = gr.Markdown(label="Results")
+        results_output = gr.Markdown(label="Results")
     
     with gr.Row():
-        with gr.Column():
-            json_output = gr.Code(
-                label="📥 Download Results (JSON)",
-                language="json",
-                lines=20
-            )
+        json_output = gr.Code(
+            label="📥 JSON Results",
+            language="json",
+            lines=20
+        )
     
     analyze_btn.click(
         fn=analyzer.process_files,
@@ -451,11 +512,10 @@ with gr.Blocks(title="Property Formula Analyzer", theme=gr.themes.Soft()) as app
     
     gr.Markdown("""
     ---
-    ### 📝 Notes:
-    - The system automatically extracts property metrics from your documents
-    - Formulas are computed iteratively to handle dependencies between formulas
-    - Non-computable formulas are listed with their missing variables
-    - All results can be downloaded as JSON for further processing
+    ### 💡 Tips:
+    - The system uses semantic variable names (e.g., `Building_Efficiency` instead of `E1`)
+    - Formulas cascade: computed values enable more formulas in subsequent iterations
+    - Non-computable formulas show which variables are missing
     """)
 
 if __name__ == "__main__":