import math
def create_lattice_svg():
# --- Configuration ---
# SVG dimensions.
row_height = 95
node_spacing = 77
node_radius = 20
# --- Lattice Data ---
# Define the numbers for each row of the lattice based on number of prime factors.
# The key (0-4) serves as both the number of factors and the row identifier.
lattice_data = {
4: [0], # The top node (0)
3: [8, 12, 18, 20, 27], # Numbers with three prime factors
2: [4, 6, 9, 10, 14], # Numbers with two prime factors
1: [2, 3, 5, 7], # Prime numbers
0: [1] # The number 1 (zero factors)
}
# --- Create a list of node objects with positions ---
nodes = []
# Determine the widest row to calculate total SVG width.
max_nodes_per_row = 0
for row in lattice_data.values():
if len(row) > max_nodes_per_row:
max_nodes_per_row = len(row)
# Adjust for ellipsis node
max_nodes_per_row += 1
# Calculate total SVG dimensions with padding.
width = max_nodes_per_row * node_spacing
num_rows = len(lattice_data)
height = num_rows * row_height
# Build the nodes list and calculate their positions.
row_keys = sorted(lattice_data.keys(), reverse=True)
for i, num_factors in enumerate(row_keys):
numbers = sorted(lattice_data[num_factors])
# Ellipses are added to rows that aren't the top or bottom
has_ellipsis = num_factors not in [0, 4]
# Calculate the y-position for the current row, from the top down.
y_pos = row_height * i + row_height / 2
# Calculate x-positions to center the numbers in the row.
num_nodes_in_row = len(numbers) + (1 if has_ellipsis else 0)
half_width = width / 2
half_node_span = ((num_nodes_in_row -1) / 2) * node_spacing
start_x = half_width - half_node_span
for j, number in enumerate(numbers):
x_pos = start_x + j * node_spacing
node = {
'value': number,
'type': 'number',
'num_factors': num_factors,
'x_pos': x_pos,
'y_pos': y_pos
}
nodes.append(node)
# Add positions for ellipsis nodes.
if has_ellipsis:
ellipsis_x_pos = start_x + len(numbers) * node_spacing
ellipsis_y_pos = y_pos
ellipsis_node = {
'value': '···',
'type': 'ellipsis',
'num_factors': num_factors,
'x_pos': ellipsis_x_pos,
'y_pos': ellipsis_y_pos
}
nodes.append(ellipsis_node)
# --- Start the SVG string with the header and styles ---
svg_string = f'''<svg width="{width}" height="{height}" xmlns="http://www.w3.org/2000/svg">
<defs>
<style type="text/css">
.solid-line {{
fill: none;
stroke: #000000;
stroke-width: 1.5;
stroke-linecap: butt;
stroke-linejoin: miter;
stroke-miterlimit: 4;
stroke-opacity: 1;
stroke-dasharray: none;
stroke-dashoffset: 0;
}}
.dotted-line {{
fill: none;
stroke: #000000;
stroke-width: 1.5;
stroke-linecap: butt;
stroke-linejoin: miter;
stroke-miterlimit: 4;
stroke-opacity: 1;
stroke-dasharray: 1.5, 4.5;
stroke-dashoffset: 0;
}}
.node-circle {{
fill: #ffffff;
fill-opacity: 1;
fill-rule: evenodd;
stroke: none;
}}
.node-text {{
font-size: 30px;
font-style: normal;
font-variant: normal;
font-weight: normal;
font-stretch: normal;
text-indent: 0;
text-align: start;
text-decoration: none;
line-height: normal;
letter-spacing: normal;
word-spacing: normal;
text-transform: none;
direction: ltr;
block-progression: tb;
writing-mode: lr-tb;
text-anchor: middle;
dominant-baseline: middle;
color: #000000;
fill: #000000;
fill-opacity: 1;
fill-rule: nonzero;
stroke: none;
stroke-width: 1px;
marker: none;
visibility: visible;
display: inline;
overflow: visible;
enable-background: accumulate;
font-family: Liberation Serif, Times New Roman, serif;
}}
</style>
</defs>'''
# Painting order: lines first, then circles, then text on top. This is the order in which we add elements to the SVG string.
# --- Step 1: Draw all Lattice Lines ---
for parent_node in nodes:
for child_node in nodes:
# Skip if they are the same node
if parent_node == child_node:
continue
# Only connect nodes that are one level apart in terms of prime factors
if parent_node['num_factors'] != child_node['num_factors'] + 1:
continue
x1, y1 = parent_node['x_pos'], parent_node['y_pos']
x2, y2 = child_node['x_pos'], child_node['y_pos']
line_class = None
# Solid lines between numbers based on divisibility
if (parent_node['type'] == 'number' and child_node['type'] == 'number' and
parent_node['value'] % child_node['value'] == 0):
line_class = "solid-line"
# Dotted lines from numbers/ellipsis in the row below to the ellipsis
if (parent_node['type'] == 'ellipsis'):
line_class = "dotted-line"
# Dotted lines from 0 to the top row
if (parent_node['value'] == 0 and child_node['num_factors'] == 3):
line_class = "dotted-line"
# If a condition is met, draw the line
if line_class:
# Adjust start and end points of lines to meet the circle edges.
dy = y2 - y1
dx = x2 - x1
angle = math.atan2(dy, dx)
x1_adj = x1 + node_radius * math.cos(angle)
y1_adj = y1 + node_radius * math.sin(angle)
x2_adj = x2 - node_radius * math.cos(angle)
y2_adj = y2 - node_radius * math.sin(angle)
svg_string += f'''
<line x1="{x1_adj}" y1="{y1_adj}" x2="{x2_adj}" y2="{y2_adj}" class="{line_class}" />'''
# --- Step 2: Draw all Lattice Nodes ---
# actually, it looks better without the circles, they just cut off the lines
#for node in nodes:
# svg_string += f'''
#<circle cx="{node['x_pos']}" cy="{node['y_pos']}" r="{node_radius}" class="node-circle" />'''
# --- Step 3: Draw all Lattice Node Text ---
for node in nodes:
text_content = node['value']
svg_string += f'''
<text x="{node['x_pos']}" y="{node['y_pos']}" dy="0.1em" class="node-text">{text_content}</text>'''
# --- Close the SVG tag ---
svg_string += "\n</svg>"
return svg_string
if __name__ == "__main__":
svg_code = create_lattice_svg()
# Write the SVG string to a file
file_path = "divisibility_lattice.svg"
with open(file_path, "w") as f:
f.write(svg_code)
print(f"SVG file generated successfully at: {file_path}")
