Update app.py

app.py

@@ -11,6 +11,7 @@ class SemanticFormulaAnalyzer:
         self.formula_file_path = formula_file_path
         self.formulas = {}
         self.computed_values = {}
+        self.defaults = {}
         self.load_formulas()
     
     def load_formulas(self):
@@ -19,10 +20,7 @@ class SemanticFormulaAnalyzer:
             with open(self.formula_file_path, 'r', encoding='utf-8') as f:
                 content = f.read()
             
-            # Parse semantic formulas: Variable_Name = formula
-            # Pattern: capture variable name, formula, and description
             lines = content.split('\n')
-            
             current_formula_name = None
             current_formula = None
             current_description = None
@@ -30,30 +28,23 @@ class SemanticFormulaAnalyzer:
             for line in lines:
                 line = line.strip()
                 
-                # Skip empty lines and section headers
                 if not line or line.startswith('#'):
+                    if line.startswith('# Description:'):
+                        current_description = line.replace('# Description:', '').strip()
                     continue
                 
-                # Check if line contains a formula assignment
-                if '=' in line and not line.startswith('#'):
-                    # Save previous formula if exists
+                if '=' in line:
                     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
-                
-                # 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,
@@ -100,15 +91,14 @@ class SemanticFormulaAnalyzer:
         
         extracted_data = {}
         
-        # Comprehensive extraction patterns with semantic names
+        # Comprehensive extraction patterns
         patterns = {
             # 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'],
+            'GROSS_SF': [r'Building\s+(?:Size|SF)\s*:?\s*([\d,]+)', r'Gross\s+SF\s*:?\s*([\d,]+)', r'GSF\s*:?\s*([\d,]+)'],
             '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,]+)'],
+            'RETAIL_SF': [r'Retail\s+SF\s*:?\s*([\d,]+)', r'Retail\s+Space\s*:?\s*([\d,]+)\s*SF'],
             
             # Financial - Core
             'PRICE': [r'(?:Asking\s+)?Price\s*:?\s*\$\s*([\d,]+)', r'Purchase\s+Price\s*:?\s*\$\s*([\d,]+)'],
@@ -116,58 +106,88 @@ class SemanticFormulaAnalyzer:
             '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.]+)%'],
+            'VACANCY_RATE': [r'Vacancy\s*(?:Rate)?\s*(?:\()?([\d.]+)%'],
             
             # Operating Expenses
-            'OPEX': [r'Operating\s+Expenses\s*:?\s*\$?\s*([\d,]+)', r'Total\s+Operating\s+Expenses\s*=?\s*\$?\s*([\d,]+)'],
+            'OPEX': [r'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*)'],
+            'REAL_ESTATE_TAXES': [r'(?:Real\s+Estate\s+|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_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*)'],
-            'MANAGEMENT_FEE_PERCENTAGE': [r'Management\s*.*?(\d+)%', r'Management\s*@\s*([\d.]+)%'],
             'PROFESSIONAL_FEES': [r'Professional\s+Fees\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
+            'MANAGEMENT_FEE': [r'Management\s*(?:\([^)]+\))?\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
+            'MANAGEMENT_FEE_PERCENTAGE': [r'Management\s*.*?([\d.]+)%'],
             
-            # Rates and Percentages
+            # Rates
             '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.]+)%?'],
+            'INTEREST_RATE_BASIS_POINTS': [r'Interest\s+Rate\s*:?\s*(\d+)\s*(?:bps|basis\s+points)'],
             '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.]+)%?'],
+            # Rent & Revenue
+            'FREE_MARKET_RENT_PSF': [r'Free\s+Market\s+Rent\s*:?\s*\$?\s*([\d,]+\.?\d*)\s*(?:/\s*)?(?:PSF|per\s+SF)'],
+            'AFFORDABLE_RENT_PSF': [r'Affordable\s+Rent\s*:?\s*\$?\s*([\d,]+\.?\d*)\s*(?:/\s*)?(?:PSF|per\s+SF)'],
+            'RETAIL_RENT_PSF': [r'Retail\s+Rent\s*:?\s*\$?\s*([\d,]+\.?\d*)\s*(?:/\s*)?(?:PSF|per\s+SF)'],
+            'OTHER_INCOME_PER_UNIT': [r'Other\s+Income\s*:?\s*\$?\s*([\d,]+\.?\d*)\s*(?:/\s*)?(?:unit|per\s+unit)'],
+            'PARKING_INCOME': [r'Parking\s+Income\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
+            
+            # Inflation & Time
+            'REVENUE_INFLATION_RATE': [r'Revenue\s+Inflation\s*:?\s*([\d.]+)%?'],
+            'EXPENSE_INFLATION_RATE': [r'Expense\s+Inflation\s*:?\s*([\d.]+)%?'],
+            'LEASE_UP_MONTHS': [r'Lease[- ]?Up\s+Period\s*:?\s*(\d+)\s*months?'],
+            'STABILIZATION_MONTHS': [r'Stabilization\s+Period\s*:?\s*(\d+)\s*months?'],
+            'CONSTRUCTION_MONTHS': [r'Construction\s+(?:Period|Duration)\s*:?\s*(\d+)\s*months?'],
+            'HOLD_PERIOD_MONTHS': [r'Hold\s+Period\s*:?\s*(\d+)\s*months?'],
             
             # 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,]+)'],
+            
+            # Soft Costs Components
+            'ARCHITECTURE_AND_INTERIOR_COST': [r'(?:Architecture|A&I)\s*(?:&|and)?\s*Interior\s*:?\s*\$?\s*([\d,]+)'],
+            'STRUCTURAL_ENGINEERING_COST': [r'Structural\s+Engineering\s*:?\s*\$?\s*([\d,]+)'],
+            'MEP_ENGINEERING_COST': [r'MEP\s+Engineering\s*:?\s*\$?\s*([\d,]+)'],
+            'CIVIL_ENGINEERING_COST': [r'Civil\s+Engineering\s*:?\s*\$?\s*([\d,]+)'],
+            'CONTROLLED_INSPECTIONS_COST': [r'(?:Controlled\s+)?Inspections?\s*:?\s*\$?\s*([\d,]+)'],
+            'SURVEYING_COST': [r'Surveying\s*:?\s*\$?\s*([\d,]+)'],
+            'UTILITIES_CONNECTION_COST': [r'Utilities?\s+Connection\s*:?\s*\$?\s*([\d,]+)'],
+            'ADVERTISING_AND_MARKETING_COST': [r'(?:Advertising|Marketing)\s*:?\s*\$?\s*([\d,]+)'],
+            'ACCOUNTING_COST': [r'Accounting\s*:?\s*\$?\s*([\d,]+)'],
+            'MONITORING_COST': [r'Monitoring\s*:?\s*\$?\s*([\d,]+)'],
+            'FF_AND_E_COST': [r'FF&E\s*:?\s*\$?\s*([\d,]+)'],
+            'ENVIRONMENTAL_CONSULTANT_FEE': [r'Environmental\s+Consultant\s*:?\s*\$?\s*([\d,]+)'],
+            'MISCELLANEOUS_CONSULTANTS_FEE': [r'Misc(?:ellaneous)?\s+Consultants\s*:?\s*\$?\s*([\d,]+)'],
+            'GENERAL_LEGAL_COST': [r'(?:General\s+)?Legal\s*:?\s*\$?\s*([\d,]+)'],
+            'REAL_ESTATE_TAXES_DURING_CONSTRUCTION': [r'(?:RE\s+)?Taxes\s+During\s+Construction\s*:?\s*\$?\s*([\d,]+)'],
+            'MISCELLANEOUS_ADMIN_COST': [r'Misc(?:ellaneous)?\s+Admin\s*:?\s*\$?\s*([\d,]+)'],
+            'IBR_COST': [r'IBR\s*:?\s*\$?\s*([\d,]+)'],
+            'PROJECT_TEAM_COST': [r'Project\s+Team\s*:?\s*\$?\s*([\d,]+)'],
+            'PEM_FEES': [r'PEM\s+Fees\s*:?\s*\$?\s*([\d,]+)'],
+            'BANK_FEES': [r'Bank\s+Fees\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,]+)'],
+            
+            # Capital Stack
+            'FINANCING_COST': [r'Financing\s+Cost\s*:?\s*\$?\s*([\d,]+)'],
+            'FINANCING_PERCENTAGE': [r'Financing\s+(?:Percentage|%)\s*:?\s*([\d.]+)%?'],
+            'INTEREST_RESERVE': [r'Interest\s+Reserve\s*:?\s*\$?\s*([\d,]+)'],
+            'LOAN_AMOUNT': [r'Loan\s+Amount\s*:?\s*\$?\s*([\d,]+)'],
+            
+            # Exit Strategy
+            'SALE_COST_PERCENTAGE': [r'Sale\s+Cost\s*:?\s*([\d.]+)%?'],
+            'GP_PREF_RATE': [r'GP\s+Pref(?:erred)?\s+Rate\s*:?\s*([\d.]+)%?'],
+            'LP_PREF_RATE': [r'LP\s+Pref(?:erred)?\s+Rate\s*:?\s*([\d.]+)%?'],
+            'PROMOTE_PERCENTAGE': [r'Promote\s*:?\s*([\d.]+)%?'],
         }
         
         for key, pattern_list in patterns.items():
@@ -182,20 +202,15 @@ class SemanticFormulaAnalyzer:
                     except (ValueError, IndexError):
                         continue
         
-        # 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
+        # Post-processing: percentages
+        if 'INTEREST_RATE' in extracted_data and extracted_data['INTEREST_RATE'] > 1:
+            extracted_data['INTEREST_RATE'] = extracted_data['INTEREST_RATE'] / 100
             extracted_data['INTEREST_RATE_DECIMAL'] = extracted_data['INTEREST_RATE']
         
-        if 'LTC' in extracted_data:
-            if extracted_data['LTC'] > 1:
-                extracted_data['LTC'] = extracted_data['LTC'] / 100
+        if 'LTC' in extracted_data and extracted_data['LTC'] > 1:
+            extracted_data['LTC'] = extracted_data['LTC'] / 100
             extracted_data['LTC_RATIO'] = extracted_data['LTC']
         
-        if 'CAP_RATE' in extracted_data and extracted_data['CAP_RATE'] < 1:
-            extracted_data['CAP_RATE'] = extracted_data['CAP_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
@@ -209,51 +224,84 @@ class SemanticFormulaAnalyzer:
         if 'BUILDING_SF' in extracted_data and 'GROSS_SF' not in extracted_data:
             extracted_data['GROSS_SF'] = extracted_data['BUILDING_SF']
         
-        if 'GROSS_SF' in extracted_data and 'BUILDING_SF' not in extracted_data:
-            extracted_data['BUILDING_SF'] = extracted_data['GROSS_SF']
-        
-        # 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
         
-        # Map EGI synonyms
         if 'EGI' in extracted_data and 'EFFECTIVE_GROSS_INCOME' not in extracted_data:
             extracted_data['EFFECTIVE_GROSS_INCOME'] = extracted_data['EGI']
         
-        if 'EFFECTIVE_GROSS_INCOME' in extracted_data and 'EGI' not in extracted_data:
-            extracted_data['EGI'] = extracted_data['EFFECTIVE_GROSS_INCOME']
-        
-        # Map NOI synonyms
         if 'NOI' in extracted_data and 'NET_OPERATING_INCOME' not in extracted_data:
             extracted_data['NET_OPERATING_INCOME'] = extracted_data['NOI']
         
-        if 'NET_OPERATING_INCOME' in extracted_data and 'NOI' not in extracted_data:
-            extracted_data['NOI'] = extracted_data['NET_OPERATING_INCOME']
-        
-        # Map OPEX synonyms
         if 'OPEX' in extracted_data and 'TOTAL_OPERATING_EXPENSES' not in extracted_data:
             extracted_data['TOTAL_OPERATING_EXPENSES'] = extracted_data['OPEX']
         
-        if 'TOTAL_OPERATING_EXPENSES' in extracted_data and 'OPEX' not in extracted_data:
-            extracted_data['OPEX'] = extracted_data['TOTAL_OPERATING_EXPENSES']
+        # DEFAULT VALUES & ASSUMPTIONS
+        self.defaults = {
+            'MANAGEMENT_FEE_PERCENTAGE': 0.03,
+            'VACANCY_RATE': 0.05,
+            'REVENUE_INFLATION_RATE': 0.03,
+            'EXPENSE_INFLATION_RATE': 0.025,
+            'INTEREST_RATE_BASIS_POINTS': 500,
+            'EXIT_CAP_RATE_DECIMAL': 0.05,
+            'SALE_COST_PERCENTAGE': 0.02,
+            'LTC_RATIO': 0.75,
+            'FINANCING_PERCENTAGE': 0.01,
+            'CONSTRUCTION_MONTHS': 24,
+            'LEASE_UP_MONTHS': 12,
+            'STABILIZATION_MONTHS': 6,
+            'HOLD_PERIOD_MONTHS': 84,
+            'GP_PREF_RATE': 0.08,
+            'LP_PREF_RATE': 0.08,
+            'PROMOTE_PERCENTAGE': 0.20,
+        }
         
-        # 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']
+        # Apply defaults
+        for key, default_value in self.defaults.items():
+            if key not in extracted_data:
+                extracted_data[key] = default_value
+        
+        # Calculate soft costs as % of construction if available
+        if 'TOTAL_CONSTRUCTION_GMP' in extracted_data:
+            gmp = extracted_data['TOTAL_CONSTRUCTION_GMP']
+            soft_defaults = {
+                'ARCHITECTURE_AND_INTERIOR_COST': 0.025,
+                'STRUCTURAL_ENGINEERING_COST': 0.01,
+                'MEP_ENGINEERING_COST': 0.015,
+                'CIVIL_ENGINEERING_COST': 0.005,
+                'CONTROLLED_INSPECTIONS_COST': 0.003,
+                'SURVEYING_COST': 0.002,
+                'UTILITIES_CONNECTION_COST': 0.005,
+                'ACCOUNTING_COST': 0.001,
+                'MONITORING_COST': 0.001,
+                'FF_AND_E_COST': 0.01,
+                'ENVIRONMENTAL_CONSULTANT_FEE': 0.002,
+                'MISCELLANEOUS_CONSULTANTS_FEE': 0.005,
+                'GENERAL_LEGAL_COST': 0.003,
+                'REAL_ESTATE_TAXES_DURING_CONSTRUCTION': 0.005,
+                'MISCELLANEOUS_ADMIN_COST': 0.002,
+                'IBR_COST': 0.003,
+                'PROJECT_TEAM_COST': 0.005,
+                'PEM_FEES': 0.01,
+                'BANK_FEES': 0.005,
+            }
+            
+            for key, pct in soft_defaults.items():
+                if key not in extracted_data:
+                    extracted_data[key] = gmp * pct
+        
+        # Calculate construction GMP if cost per GSF available
+        if 'CONSTRUCTION_COST_PER_GSF' in extracted_data and 'GROSS_SF' in extracted_data and 'TOTAL_CONSTRUCTION_GMP' not in extracted_data:
+            extracted_data['TOTAL_CONSTRUCTION_GMP'] = extracted_data['CONSTRUCTION_COST_PER_GSF'] * extracted_data['GROSS_SF']
         
         return extracted_data
     
     def extract_variables_from_formula(self, formula: str) -> List[str]:
         """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 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]]:
@@ -270,10 +318,7 @@ class SemanticFormulaAnalyzer:
     def safe_eval_formula(self, formula: str, data: Dict[str, Any]) -> Any:
         """Safely evaluate a semantic formula"""
         try:
-            # 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)
             
@@ -282,11 +327,8 @@ class SemanticFormulaAnalyzer:
                     value = all_data[var]
                     formula_eval = re.sub(r'\b' + var + r'\b', str(value), formula_eval)
             
-            # Replace ** with ** (already correct for Python)
-            # Handle any remaining math operations
             formula_eval = formula_eval.replace('^', '**')
             
-            # Evaluate safely
             safe_dict = {
                 'min': min,
                 'max': max,
@@ -308,14 +350,11 @@ class SemanticFormulaAnalyzer:
                 return "❌ No files uploaded", "", ""
             
             file_paths = [f.name for f in files]
-            
-            # Extract data
             extracted_data = self.extract_data_from_files(file_paths)
             
             if not extracted_data:
                 return "❌ No data could be extracted from the files", "", ""
             
-            # Reset computed values
             self.computed_values = {}
             
             # Multiple passes for dependency resolution
@@ -327,7 +366,6 @@ class SemanticFormulaAnalyzer:
                 newly_computed = 0
                 
                 for formula_name, formula_info in self.formulas.items():
-                    # Skip if already computed
                     if formula_name in computable_formulas:
                         continue
                     
@@ -348,7 +386,6 @@ class SemanticFormulaAnalyzer:
                                 'iteration': iteration + 1
                             }
                             
-                            # Store for cascading
                             self.computed_values[formula_name] = result
                             newly_computed += 1
                             
@@ -371,43 +408,65 @@ class SemanticFormulaAnalyzer:
                 if newly_computed == 0:
                     break
             
-            # Remove computed formulas from non-computable list
             for formula_name in computable_formulas.keys():
                 non_computable_formulas.pop(formula_name, None)
             
+            # 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))
+            
             # Create summary
+            defaults_applied = sum(1 for k in extracted_data.keys() if k in self.defaults)
+            
             summary = f"""
 ## 📊 Analysis Summary
 
 **Total Formulas Loaded:** {len(self.formulas)}
-**✅ Computable Formulas:** {len(computable_formulas)}
-**❌ Non-Computable Formulas:** {len(non_computable_formulas)}
+**✅ Computable Formulas:** {len(computable_formulas)} ({len(computable_formulas) / len(self.formulas) * 100:.1f}%)
+**❌ Non-Computable Formulas:** {len(non_computable_formulas)} ({len(non_computable_formulas) / len(self.formulas) * 100:.1f}%)
 **📄 Files Processed:** {len(file_paths)}
 **🔢 Data Points Extracted:** {len(extracted_data)}
+**🎯 Defaults Applied:** {defaults_applied}
 **🔄 Computation Iterations:** {iteration + 1}
-**📈 Success Rate:** {(len(computable_formulas) / len(self.formulas) * 100):.1f}%
+
+### 📈 Progress by Iteration
 """
             
+            for iter_num in sorted(by_iteration.keys()):
+                summary += f"- Iteration {iter_num}: {len(by_iteration[iter_num])} formulas computed\n"
+            
+            # Analyze missing variables
+            missing_var_count = {}
+            if non_computable_formulas:
+                for name, info in non_computable_formulas.items():
+                    for var in info.get('missing_variables', []):
+                        if var not in missing_var_count:
+                            missing_var_count[var] = []
+                        missing_var_count[var].append(name)
+                
+                top_blockers = sorted(missing_var_count.items(), key=lambda x: len(x[1]), reverse=True)[:5]
+                if top_blockers:
+                    summary += f"\n### 🚫 Top 5 Missing Variables\n"
+                    for var, blocked in top_blockers:
+                        summary += f"- **{var}**: Blocks {len(blocked)} formulas\n"
+            
             # Extracted data display
             data_display = "## 📥 Extracted Property Data\n\n"
-            data_display += "| Variable | Value |\n|----------|-------|\n"
+            data_display += "| Variable | Value | Source |\n|----------|-------|--------|\n"
             for key, value in sorted(extracted_data.items()):
+                source = "📄 Document" if key not in self.defaults else "⚙️ Default"
                 if isinstance(value, float):
-                    data_display += f"| {key} | {value:,.4f} |\n"
+                    data_display += f"| {key} | {value:,.4f} | {source} |\n"
                 else:
-                    data_display += f"| {key} | {value} |\n"
+                    data_display += f"| {key} | {value} | {source} |\n"
             
             # Results display
             results_display = "## ✅ Computed Formulas\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]):
@@ -415,22 +474,22 @@ class SemanticFormulaAnalyzer:
                     results_display += f"*{info['description']}*\n"
                     results_display += f"`{info['formula']}`\n\n"
             
+            # Non-computable formulas
             # if non_computable_formulas:
             #     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"**{name}**: {info['description']}\n"
-            #         if info.get('missing_variables'):
-            #             missing = info['missing_variables'][:5]
-            #             results_display += f"Missing: {', '.join(missing)}\n"
-            #         results_display += "\n"
-            
-            # JSON output
+            #     if missing_var_count:
+            #         results_display += "### 🚫 Top Missing Variables (Blocking Multiple Formulas)\n\n"
+            #         sorted_missing = sorted(missing_var_count.items(), key=lambda x: len(x[1]), reverse=True)
+                    
+            #         for idx, (var, blocked_formulas) in enumerate(sorted_missing[:15]):
+            #             results_display += f"{idx+1}. **{var}** - Blocks {len(blocked_formulas)} formulas\n"
+            #             sample = blocked_formulas[:3]
+            #             results_display += f"   - Affects: {', '.join(sample)}"
+            #             if len(blocked_formulas) > 3:
+            #                 results_display += f" ... and {len(blocked_formulas) - 3} more"
+            #             results_display += "\n"
+            #         results_display
             json_output = {
                 'summary': {
                     'total_formulas': len(self.formulas),