spa-l2-cairo-shop-knn

Rerun

import geopandas as gpd
import pandas as pd
import numpy as np
import json
from sklearn.neighbors import NearestNeighbors

def normalize_names(df, name_col):
    """
    Normalizes names by stripping whitespace, lowercasing, 
    and grouping similar names.
    Since the prompt mentions 'inconsistent spellings', 
    a simple approach is to group by a normalized version.
    """
    # Basic cleanup
    df['norm_temp'] = df[name_col].str.strip().str.lower()
    
    # For real 'inconsistent spelling', we might need fuzzy matching,
    # but let's try grouping by the cleaned string first.
    # If there are still multiple, we take the most frequent one as canonical.
    
    # Group by the normalized string and find the most frequent original name
    mapping = {}
    for name in df[name_col].unique():
        norm = str(name).strip().lower()
        mapping[name] = norm
        
    # Actually, the requirement says "the same shop_id always carries the same normalised_name"
    # and "all shops belonging to one chain share a single canonical spelling".
    # This implies we should group by a similarity metric or just use the cleaned lowercase.
    # Let's use the cleaned lowercase for 'normalised_name'.
    
    df['normalised_name'] = df[name_col].str.strip().str.title()
    # However, title case might not be enough if "Starbucks" and "Starbucks Corp" are different.
    # Let's try a more robust way: group by lowercase and take the most common title case.
    
    return df

def solve():
    # Load data
    shops = gpd.read_file('cairo_retail.gpkg', layer='shops')
    anchors = gpd.read_file('cairo_retail.gpkg', layer='anchors')
    
    # CRS is Egypt 1907 / Red Belt (EPSG:22992), which is in meters. Good.
    
    # 1. Normalize Names
    # We need a way to map inconsistent names to a canonical one.
    # Let's group by a simplified version of the name.
    
    def get_canonical_mapping(series):
        # Simplify: strip, lower, remove common suffixes
        def simplify(s):
            if not isinstance(s, str): return ""
            s = s.strip().lower()
            # Remove common suffixes/noise if any (this is a heuristic)
            suffixes = [' corp', ' inc', ' ltd', ' co', ' store']
            for suff in suffixes:
                if s.endswith(suff):
                    s = s[:len(s)-len(suff)]
            return s.strip()
        
        simplified = series.apply(simplify)
        
        # For each simplified name, find the most common original name (title cased)
        mapping = {}
        for sim_name in simplified.unique():
            # Get all original names that map to this simplified name
            mask = (simplified == sim_name)
            originals = series[mask]
            # Find the most frequent original name, title cased
            canonical = originals.value_counts().idxmax().title()
            mapping[sim_name] = canonical
            
        return simplified, mapping

    shops['simple_name'], shop_name_map = get_canonical_mapping(shops['raw_name'])
    shops['normalised_name'] = shops['simple_name'].map(shop_name_map)
    
    anchors['simple_name'], anchor_name_map = get_canonical_mapping(anchors['anchor_name'])
    anchors['anchor_name_normalised'] = anchors['simple_name'].map(anchor_name_map)
    
    # 2. KNN for Shops
    # We need 5 nearest shops for each anchor.
    shop_coords = np.array(list(zip(shops.geometry.x, shops.geometry.y)))
    anchor_coords = np.array(list(zip(anchors.geometry.x, anchors.geometry.y)))
    
    nn_shops = NearestNeighbors(n_neighbors=5, metric='euclidean')
    nn_shops.fit(shop_coords)
    
    distances_shops, indices_shops = nn_shops.kneighbors(anchor_coords)
    
    # 3. KNN for Sibling Anchors
    # "3 closest sibling anchors" - a sibling is an anchor of the same chain.
    # Wait, "sibling anchors" might mean anchors of the same chain.
    # Let's check if anchors have a chain/name. They have 'anchor_name'.
    # "all shops belonging to one chain share a single canonical spelling"
    # "3 closest sibling anchors" -> anchors that have the same normalised_name.
    
    results = []
    
    for i in range(len(anchors)):
        anchor = anchors.iloc[i]
        a_id = anchor['anchor_id']
        a_name_norm = anchor['anchor_name_normalised']
        a_geom = anchor.geometry
        
        # KNN Shops
        knn_list = []
        for idx_in_knn, shop_idx in enumerate(indices_shops[i]):
            shop = shops.iloc[shop_idx]
            dist = distances_shops[i][idx_in_knn]
            knn_list.append({
                "shop_id": str(shop['shop_id']),
                "normalised_name": str(shop['normalised_name']),
                "distance_m": float(dist),
                "within_1km": bool(dist <= 1000)
            })
            
        # Sibling Anchors
        # Siblings are anchors with the same anchor_name_normalised, but NOT the same anchor_id.
        siblings = anchors[(anchors['anchor_name_normalised'] == a_name_norm) & (anchors['anchor_id'] != a_id)]
        
        # We need 3 closest siblings.
        # Calculate distance from current anchor to all siblings
        if not siblings.empty:
            sibling_coords = np.array(list(zip(siblings.geometry.x, siblings.geometry.y)))
            anchor_coord = np.array([[a_geom.x, a_geom.y]])
            
            # Distances to siblings
            dists_to_siblings = np.linalg.norm(sibling_coords - anchor_coord, axis=1)
            sibling_df = siblings.copy()
            sibling_df['dist_to_anchor'] = dists_to_siblings
            
            # Get 3 closest
            closest_siblings = sibling_df.nsmallest(3, 'dist_to_anchor')
            
            # 5x3 distance matrix
            # Rows: knn_list (5)
            # Cols: closest_siblings (up to 3)
            # Matrix value: distance from knn_shop to sibling_anchor
            
            # To compute this efficiently, we need the coordinates of the 5 shops
            knn_shop_coords = shop_coords[indices_shops[i]]
            sib_coords = np.array(list(zip(closest_siblings.geometry.x, closest_siblings.geometry.y)))
            
            # Matrix: (5, 3)
            # dist_matrix[j, k] = distance from shop j in knn to sibling k
            dist_matrix = np.zeros((5, 3))
            for j in range(5):
                for k in range(len(sib_coords)):
                    dist_matrix[j, k] = np.linalg.norm(knn_shop_coords[j] - sib_coords[k])
            
            # Fill remaining columns with 0 or some indicator? 
            # The prompt says "5x3 distance matrix from those 5 shops to the anchor's 3 closest sibling anchors".
            # If there are fewer than 3 siblings, we should probably pad with 0.0 or NaN? 
            # "5 rows by 3 numeric columns" implies we must have 3.
            # Let's assume we pad with 0.0 if siblings < 3.
            # Actually, let's check if the prompt implies we always have 3.
            # If not, the matrix shape must still be 5x3.
            
            if len(closest_siblings) < 3:
                # Pad the matrix with 0.0 if there are fewer than 3 siblings
                # Note: If I use np.zeros, it's already padded.
                # But the loop above only fills up to len(sib_coords).
                pass
                
            # The requirement says: "columns correspond to the sibling anchors in distance-ascending order"
            # Our closest_siblings is already sorted.
            
            full_matrix = dist_matrix.tolist()
            
        else:
            # No siblings found
            full_matrix = [[0.0] * 3 for _ in range(5)]
            
        results.append({
            "anchor_id": str(a_id),
            "anchor_name_normalised": str(a_name_norm),
            "knn": knn_list,
            "full_distance_matrix_m": full_matrix
        })
        
    # Write to JSON
    with open('market_neighbourhoods.json', 'w') as f:
        json.dump(results, f, indent=2)

if __name__ == "__main__":
    solve()

import geopandas as gpd
import pandas as pd
import numpy as np
import json
from scipy.spatial import cKDTree

def get_canonical_mapping(series):
    """
    Normalizes names by stripping whitespace, lowercasing, 
    and grouping similar names.
    """
    def simplify(s):
        if not isinstance(s, str): return ""
        s = s.strip().lower()
        # Remove common noise
        suffixes = [' corp', ' inc', ' ltd', ' co', ' store', ' shop']
        for suff in suffixes:
            if s.endswith(suff):
                s = s[:len(s)-len(suff)]
        return s.strip()
    
    simplified = series.apply(simplify)
    
    # For each simplified name, find the most common original name, title cased.
    mapping = {}
    for sim_name in simplified.unique():
        mask = (simplified == sim_name)
        originals = series[mask]
        if not originals.empty:
            canonical = originals.value_counts().idxmax().title()
        else:
            canonical = sim_name.title()
        mapping[sim_name] = canonical
        
    return simplified, mapping

def solve():
    # Load data
    shops = gpd.read_file('cairo_retail.gpkg', layer='shops')
    anchors = gpd.read_file('cairo_retail.gpkg', layer='anchors')
    
    # 1. Normalize Names
    shops['simple_name'], shop_name_map = get_canonical_mapping(shops['raw_name'])
    shops['normalised_name'] = shops['simple_name'].map(shop_name_map)
    
    anchors['simple_name'], anchor_name_map = get_canonical_mapping(anchors['anchor_name'])
    anchors['anchor_name_normalised'] = anchors['simple_name'].map(anchor_name_map)
    
    # 2. KNN for Shops
    shop_coords = np.array(list(zip(shops.geometry.x, shops.geometry.y)))
    anchor_coords = np.array(list(zip(anchors.geometry.x, anchors.geometry.y)))
    
    tree_shops = cKDTree(shop_coords)
    distances_shops, indices_shops = tree_shops.query(anchor_coords, k=5)
    
    # 3. Pre-calculate Sibling Anchors
    # For each anchor, find its siblings (same normalized name, different ID)
    results = []
    
    for i in range(len(anchors)):
        anchor = anchors.iloc[i]
        a_id = str(anchor['anchor_id'])
        a_name_norm = str(anchor['anchor_name_normalised'])
        a_geom = anchor.geometry
        
        # KNN Shops
        knn_list = []
        current_knn_indices = indices_shops[i]
        current_knn_distances = distances_shops[i]
        
        for idx_in_knn, shop_idx in enumerate(current_knn_indices):
            shop = shops.iloc[shop_idx]
            dist = float(current_knn_distances[idx_in_knn])
            knn_list.append({
                "shop_id": str(shop['shop_id']),
                "normalised_name": str(shop['normalised_name']),
                "distance_m": dist,
                "within_1km": bool(dist <= 1000)
            })
            
        # Sibling Anchors
        # Siblings are anchors with the same anchor_name_normalised, but NOT the same anchor_id.
        siblings = anchors[(anchors['anchor_name_normalised'] == a_name_norm) & (anchors['anchor_id'] != anchor['anchor_id'])]
        
        full_matrix = [[0.0] * 3 for _ in range(5)]
        
        if not siblings.empty:
            sibling_coords = np.array(list(zip(siblings.geometry.x, siblings.geometry.y)))
            anchor_coord = np.array([a_geom.x, a_geom.y])
            
            # Distances to siblings
            dists_to_siblings = np.linalg.norm(sibling_coords - anchor_coord, axis=1)
            
            # Get 3 closest siblings
            # We sort indices of sibling_coords by dists_to_siblings
            closest_idx_in_siblings = np.argsort(dists_to_siblings)[:3]
            
            # Get the actual coordinates of the top 3 siblings
            sib_coords_subset = sibling_coords[closest_idx_in_siblings]
            
            # Calculate 5x3 distance matrix
            # Rows: knn_list (5), Cols: closest_siblings (up to 3)
            knn_shop_coords = shop_coords[current_knn_indices]
            
            for j in range(5):
                for k in range(len(sib_coords_subset)):
                    dist_val = np.linalg.norm(knn_shop_coords[j] - sib_coords_subset[k])
                    full_matrix[j][k] = float(dist_val)
            
        results.append({
            "anchor_id": a_id,
            "anchor_name_normalised": a_name_norm,
            "knn": knn_list,
            "full_distance_matrix_m": full_matrix
        })
        
    # Write to JSON
    with open('market_neighbourhoods.json', 'w') as f:
        json.dump(results, f, indent=2)

if __name__ == "__main__":
    solve()

import geopandas as gpd
import pandas as pd
import numpy as np
import json

def get_canonical_mapping(series):
    """
    Normalizes names by stripping whitespace, lowercasing, 
    and grouping similar names.
    """
    def simplify(s):
        if not isinstance(s, str): return ""
        s = s.strip().lower()
        # Remove common noise
        suffixes = [' corp', ' inc', ' ltd', ' co', ' store', ' shop']
        for suff in suffixes:
            if s.endswith(suff):
                s = s[:len(s)-len(suff)]
        return s.strip()
    
    simplified = series.apply(simplify)
    
    # For each simplified name, find the most common original name, title cased.
    mapping = {}
    for sim_name in simplified.unique():
        mask = (simplified == sim_name)
        originals = series[mask]
        if not originals.empty:
            # value_counts().idxmax() is fine for pandas series
            canonical = originals.value_counts().idxmax()
            # Ensure it's a string and title cased
            canonical = str(canonical).title()
        else:
            canonical = str(sim_name).title()
        mapping[sim_name] = canonical
        
    return simplified, mapping

def solve():
    # Load data
    shops = gpd.read_file('cairo_retail.gpkg', layer='shops')
    anchors = gpd.read_file('cairo_retail.gpkg', layer='anchors')
    
    # 1. Normalize Names
    shops['simple_name'], shop_name_map = get_canonical_mapping(shops['raw_name'])
    shops['normalised_name'] = shops['simple_name'].map(shop_name_map)
    
    anchors['simple_name'], anchor_name_map = get_canonical_mapping(anchors['anchor_name'])
    anchors['anchor_name_normalised'] = anchors['simple_name'].map(anchor_name_map)
    
    # 2. KNN for Shops
    # Since scipy is not available, we'll use a brute force approach 
    # or a simple manual implementation since n_anchors is small (100).
    # 100 anchors * 10000 shops = 1,000,000 distance calculations.
    # This is manageable in pure numpy.
    
    shop_coords = np.array(list(zip(shops.geometry.x, shops.geometry.y)))
    anchor_coords = np.array(list(zip(anchors.geometry.x, anchors.geometry.y)))
    
    # Brute force distance matrix: (n_anchors, n_shops)
    # To avoid memory issues, we'll process anchors in chunks or just use broadcasting
    # if it fits. (100, 10000) is only 1,000,000 floats, which is ~8MB.
    
    # dists[i, j] is distance between anchor i and shop j
    dists = np.linalg.norm(anchor_coords[:, np.newaxis, :] - shop_coords[np.newaxis, :, :], axis=2)
    
    # For each anchor, find 5 nearest shops
    # argsort each row
    sorted_shop_indices = np.argsort(dists, axis=1)
    
    # 3. Build results
    results = []
    
    for i in range(len(anchors)):
        anchor = anchors.iloc[i]
        a_id = str(anchor['anchor_id'])
        a_name_norm = str(anchor['anchor_name_normalised'])
        a_geom = anchor.geometry
        
        # KNN Shops
        knn_list = []
        # Top 5 shop indices for this anchor
        top_5_indices = sorted_shop_indices[i, :5]
        # Top 5 distances
        top_5_dists = dists[i, top_5_indices]
        
        for idx_in_knn, shop_idx in enumerate(top_5_indices):
            shop = shops.iloc[shop_idx]
            dist = float(top_5_dists[idx_in_knn])
            knn_list.append({
                "shop_id": str(shop['shop_id']),
                "normalised_name": str(shop['normalised_name']),
                "distance_m": dist,
                "within_1km": bool(dist <= 1000)
            })
            
        # Sibling Anchors
        # Siblings are anchors with the same anchor_name_normalised, but NOT the same anchor_id.
        siblings = anchors[(anchors['anchor_name_normalised'] == a_name_norm) & (anchors['anchor_id'] != anchor['anchor_id'])]
        
        full_matrix = [[0.0] * 3 for _ in range(5)]
        
        if not siblings.empty:
            sibling_coords = np.array(list(zip(siblings.geometry.x, siblings.geometry.y)))
            anchor_coord = np.array([a_geom.x, a_geom.y])
            
            # Distances to siblings
            dists_to_siblings = np.linalg.norm(sibling_coords - anchor_coord, axis=1)
            
            # Get 3 closest siblings
            # We need the indices of the smallest 3
            closest_idx_in_siblings = np.argsort(dists_to_siblings)[:3]
            
            sib_coords_subset = sibling_coords[closest_idx_in_siblings]
            
            # Calculate 5x3 distance matrix
            # Rows: knn_list (5), Cols: closest_siblings (up to 3)
            knn_shop_coords = shop_coords[top_5_indices]
            
            for j in range(5):
                for k in range(len(sib_coords_subset)):
                    dist_val = np.linalg.norm(knn_shop_coords[j] - sib_coords_subset[k])
                    full_matrix[j][k] = float(dist_val)
            
        results.append({
            "anchor_id": a_id,
            "anchor_name_normalised": a_name_norm,
            "knn": knn_list,
            "full_distance_matrix_m": full_matrix
        })
        
    # Write to JSON
    with open('market_neighbourhoods.json', 'w') as f:
        json.dump(results, f, indent=2)

if __name__ == "__main__":
    solve()

import geopandas as gpd
import pandas as pd
import numpy as np
import json

def get_canonical_mapping(series):
    """
    Normalizes names by stripping whitespace, lowercasing, 
    and grouping similar names.
    """
    def simplify(s):
        if not isinstance(s, str): return ""
        s = s.strip().lower()
        # Remove common noise
        suffixes = [' corp', ' inc', ' ltd', ' co', ' store', ' shop', ' supermarket', ' market']
        for suff in suffixes:
            if s.endswith(suff):
                s = s[:len(s)-len(suff)]
        return s.strip()
    
    simplified = series.apply(simplify)
    
    mapping = {}
    for sim_name in simplified.unique():
        mask = (simplified == sim_name)
        originals = series[mask]
        if not originals.empty:
            # Pick the most frequent original name
            # To be safe, handle potential non-string values in value_counts
            counts = originals.value_counts()
            canonical = counts.idxmax()
            canonical = str(canonical).strip().title()
        else:
            canonical = str(sim_name).strip().title()
        mapping[sim_name] = canonical
        
    return simplified, mapping

def solve():
    # Load data
    shops = gpd.read_file('cairo_retail.gpkg', layer='shops')
    anchors = gpd.read_file('cairo_retail.gpkg', layer='anchors')
    
    # 1. Normalize Names
    shops['simple_name'], shop_name_map = get_canonical_mapping(shops['raw_name'])
    shops['normalised_name'] = shops['simple_name'].map(shop_name_map)
    
    anchors['simple_name'], anchor_name_map = get_canonical_mapping(anchors['anchor_name'])
    anchors['anchor_name_normalised'] = anchors['simple_name'].map(anchor_name_map)
    
    # 2. KNN for Shops
    # Brute force distance matrix: (n_anchors, n_shops)
    shop_coords = np.array(list(zip(shops.geometry.x, shops.geometry.y)))
    anchor_coords = np.array(list(zip(anchors.geometry.x, anchors.geometry.y)))
    
    # dists[i, j] is distance between anchor i and shop j
    # Using broadcasting: (n_anchors, 1, 2) - (1, n_shops, 2)
    diff = anchor_coords[:, np.newaxis, :] - shop_coords[np.newaxis, :, :]
    dists = np.linalg.norm(diff, axis=2)
    
    # For each anchor, find 5 nearest shops
    sorted_shop_indices = np.argsort(dists, axis=1)
    
    # 3. Build results
    results = []
    
    for i in range(len(anchors)):
        anchor = anchors.iloc[i]
        a_id = str(anchor['anchor_id'])
        a_name_norm = str(anchor['anchor_name_normalised'])
        a_geom = anchor.geometry
        
        # KNN Shops
        knn_list = []
        top_5_indices = sorted_shop_indices[i, :5]
        top_5_dists = dists[i, top_5_indices]
        
        for idx_in_knn, shop_idx in enumerate(top_5_indices):
            shop = shops.iloc[shop_idx]
            dist = float(top_5_dists[idx_in_knn])
            knn_list.append({
                "shop_id": str(shop['shop_id']),
                "normalised_name": str(shop['normalised_name']),
                "distance_m": dist,
                "within_1km": bool(dist <= 1000)
            })
            
        # Sibling Anchors
        # Siblings are anchors with the same anchor_name_normalised, but NOT the same anchor_id.
        siblings = anchors[(anchors['anchor_name_normalised'] == a_name_norm) & (anchors['anchor_id'] != anchor['anchor_id'])]
        
        full_matrix = [[0.0] * 3 for _ in range(5)]
        
        if not siblings.empty:
            sibling_coords = np.array(list(zip(siblings.geometry.x, siblings.geometry.y)))
            anchor_coord = np.array([a_geom.x, a_geom.y])
            
            # Distances to siblings
            dists_to_siblings = np.linalg.norm(sibling_coords - anchor_coord, axis=1)
            
            # Get 3 closest siblings
            closest_idx_in_siblings = np.argsort(dists_to_siblings)[:3]
            sib_coords_subset = sibling_coords[closest_idx_in_siblings]
            
            # Calculate 5x3 distance matrix
            # Rows: knn_list (5), Cols: closest_siblings (up to 3)
            knn_shop_coords = shop_coords[top_5_indices]
            
            for j in range(5):
                for k in range(len(sib_coords_subset)):
                    dist_val = np.linalg.norm(knn_shop_coords[j] - sib_coords_subset[k])
                    full_matrix[j][k] = float(dist_val)
            
        results.append({
            "anchor_id": a_id,
            "anchor_name_normalised": a_name_norm,
            "knn": knn_list,
            "full_distance_matrix_m": full_matrix
        })
        
    # Write to JSON
    with open('market_neighbourhoods.json', 'w') as f:
        json.dump(results, f, indent=2)

if __name__ == "__main__":
    solve()

import geopandas as gpd
import pandas as pd
import numpy as np
import json

def get_canonical_mapping(series):
    """
    Normalizes names by stripping whitespace, lowercasing, 
    and grouping similar names.
    """
    def simplify(s):
        if not isinstance(s, str): return ""
        s = s.strip().lower()
        # Remove common noise
        suffixes = [' corp', ' inc', ' ltd', ' co', ' store', ' shop', ' supermarket', ' market']
        for suff in suffixes:
            if s.endswith(suff):
                s = s[:len(s)-len(suff)]
        return s.strip()
    
    simplified = series.apply(simplify)
    
    mapping = {}
    for sim_name in simplified.unique():
        mask = (simplified == sim_name)
        originals = series[mask]
        if not originals.empty:
            counts = originals.value_counts()
            canonical = counts.idxmax()
            canonical = str(canonical).strip().title()
        else:
            canonical = str(sim_name).strip().title()
        mapping[sim_name] = canonical
        
    return simplified, mapping

def solve():
    # Load data
    shops = gpd.read_file('cairo_retail.gpkg', layer='shops')
    anchors = gpd.read_file('cairo_retail.gpkg', layer='anchors')
    
    # 1. Normalize Names
    # Requirement: "the same shop_id always carries the same normalised_name, 
    # and all shops belonging to one chain share a single canonical spelling."
    # "Tidy the anchor names too."
    
    shops['simple_name'], shop_name_map = get_canonical_mapping(shops['raw_name'])
    shops['normalised_name'] = shops['simple_name'].map(shop_name_map)
    
    anchors['simple_name'], anchor_name_map = get_canonical_mapping(anchors['anchor_name'])
    anchors['anchor_name_normalised'] = anchors['simple_name'].map(anchor_name_map)
    
    # 2. KNN for Shops
    shop_coords = np.array(list(zip(shops.geometry.x, shops.geometry.y)))
    anchor_coords = np.array(list(zip(anchors.geometry.x, anchors.geometry.y)))
    
    # Calculate all-to-all distances for efficiency (100 x 10000)
    diff = anchor_coords[:, np.newaxis, :] - shop_coords[np.newaxis, :, :]
    dists = np.linalg.norm(diff, axis=2)
    
    # For each anchor, find 5 nearest shops
    sorted_shop_indices = np.argsort(dists, axis=1)
    
    # 3. Build results
    results = []
    
    for i in range(len(anchors)):
        anchor = anchors.iloc[i]
        a_id = str(anchor['anchor_id'])
        a_name_norm = str(anchor['anchor_name_normalised'])
        a_geom = anchor.geometry
        
        # KNN Shops
        knn_list = []
        top_5_indices = sorted_shop_indices[i, :5]
        top_5_dists = dists[i, top_5_indices]
        
        for idx_in_knn, shop_idx in enumerate(top_5_indices):
            shop = shops.iloc[shop_idx]
            dist = float(top_5_dists[idx_in_knn])
            knn_list.append({
                "shop_id": str(shop['shop_id']),
                "normalised_name": str(shop['normalised_name']),
                "distance_m": dist,
                "within_1km": bool(dist <= 1000)
            })
            
        # Sibling Anchors
        # Siblings: same normalised name, different ID
        siblings = anchors[(anchors['anchor_name_normalised'] == a_name_norm) & (anchors['anchor_id'] != anchor['anchor_id'])]
        
        full_matrix = [[0.0] * 3 for _ in range(5)]
        
        if not siblings.empty:
            sibling_coords = np.array(list(zip(siblings.geometry.x, siblings.geometry.y)))
            anchor_coord = np.array([a_geom.x, a_geom.y])
            
            # Distances from this anchor to its siblings
            dists_to_siblings = np.linalg.norm(sibling_coords - anchor_coord, axis=1)
            
            # Get 3 closest siblings (distance-ascending)
            closest_idx_in_siblings = np.argsort(dists_to_siblings)[:3]
            sib_coords_subset = sibling_coords[closest_idx_in_siblings]
            
            # 5x3 distance matrix from those 5 shops to the 3 sibling anchors
            knn_shop_coords = shop_coords[top_5_indices]
            
            for j in range(5):
                for k in range(len(sib_coords_subset)):
                    # distance from knn_shop[j] to sibling[k]
                    d = np.linalg.norm(knn_shop_coords[j] - sib_coords_subset[k])
                    full_matrix[j][k] = float(d)
            
        results.append({
            "anchor_id": a_id,
            "anchor_name_normalised": a_name_norm,
            "knn": knn_list,
            "full_distance_matrix_m": full_matrix
        })
        
    # Write to JSON
    with open('market_neighbourhoods.json', 'w') as f:
        json.dump(results, f, indent=2)

if __name__ == "__main__":
    solve()