12 KiB
Erdős Mental Model Mass-Number Map
Status: HOLD / translation doctrine Authority: workbench synthesis; not formal proof Related:
docs/gcl/FrameworkReaderRamp.mddocs/gcl/NonCompressedGoxelGeometryDoctrine.mddocs/gcl/EquationUnderverseDoctrine.mddocs/gcl/FundamentalLawUnderverseMap.md
Purpose
This page maps the main ways mathematicians mentally model Erdős-style problems into a stack-native Mass Number holder.
The goal is not to claim that historical mathematicians literally used these internal labels.
The goal is to extract the cognitive modeling patterns that repeatedly appear in Erdős / Ramsey / extremal combinatorics work and bind them into auditable Mass Number packets.
Core move
Erdős-style problem solving is the art of changing the object until inevitability becomes visible.
A point set may become a graph.
A graph may become a coloring.
A coloring may become a density threshold.
A density threshold may become a random construction.
A random construction may become a certificate that avoidance is still possible.
A computer proof may become an order-type or signature-function search.
Mass Numbers hold these modeling choices as compressed cognitive receipts.
Public translation
For a new reader:
Mass Numbers are cognitive holder-packets for mathematical modeling strategies. They record which representation a solver used, what invariant they watched, what obstruction they avoided, what threshold they crossed, and what proof style carried the result.
Mass Number definition for Erdős work
M_E = MassNumber(ErdosModel)
Where:
M_E = {
object_model,
invariant_focus,
threshold_pressure,
obstruction_shape,
proof_engine,
compression_gain,
underverse_shadow
}
Meaning:
object_model = how the problem is mentally represented
invariant_focus = what quantity or structure must not change
threshold_pressure = what density/size/growth condition forces structure
obstruction_shape = what counterexample or forbidden pattern is being avoided
proof_engine = induction, random construction, extremal counting, geometry, computation, etc.
compression_gain = how much complexity the representation removes
underverse_shadow = what the model excludes, hides, or cannot represent
Why this is useful
Many Erdős problems look simple at the surface.
points in the plane
colored edges
integer sets
forbidden sums
large graphs
But the actual work is usually representation conversion.
geometry -> order type
points -> cups/caps
sets -> density
integers -> additive energy
coloring -> obstruction search
randomness -> existence certificate
computer enumeration -> finite model receipt
Mass Numbers provide a place to store those conversions.
Mental model families
M1: Forced-pattern model
Used for Ramsey-style thinking.
If the system is large enough, disorder cannot remain pure. Some organized substructure must appear.
Object model:
complete graph / hypergraph / colored relation
Invariant focus:
monochromatic clique, independent set, convex subset, structured subsequence
Underverse shadow:
avoidance construction: the largest structure that still avoids the forced pattern
Mass Number:
M_forced_pattern = {
object_model: colored complete graph,
invariant_focus: forced monochromatic / convex / structured subobject,
threshold_pressure: N large enough,
obstruction_shape: coloring or configuration with no desired subobject,
proof_engine: Ramsey induction / extremal counting,
compression_gain: turns chaos into unavoidable substructure,
underverse_shadow: near-counterexample space
}
M2: General-position geometry model
Used for the Happy Ending / Erdős-Szekeres point-set problem.
Treat points as unconstrained enough to avoid degeneracy, then ask when convex order becomes unavoidable.
Object model:
point set in general position
Invariant focus:
convex n-gon / cup-cap / order type
Underverse shadow:
point arrangements that delay convexity as long as possible
Mass Number:
M_general_position = {
object_model: point set / order type,
invariant_focus: convex subset,
threshold_pressure: point count,
obstruction_shape: configuration with no large convex polygon,
proof_engine: geometric Ramsey / cups-caps / order-type analysis,
compression_gain: replaces coordinates with orientation and convexity relations,
underverse_shadow: non-convex delay configurations
}
M3: Cup-cap monotonicity model
Used when geometry is mentally converted into ordered subsequences.
A point set becomes a sequence. Convexity becomes a pattern of slope changes.
Object model:
ordered sequence of points
Invariant focus:
monotone subsequence, convex subsequence, concave subsequence
Underverse shadow:
sequences engineered to avoid long monotone or convex patterns
Mass Number:
M_cup_cap = {
object_model: ordered sequence,
invariant_focus: monotonicity / convexity of subsequences,
threshold_pressure: sequence length,
obstruction_shape: alternating or layered order pattern,
proof_engine: pigeonhole / Ramsey-type subsequence argument,
compression_gain: converts geometry into order statistics,
underverse_shadow: pattern-avoidance sequence
}
M4: Probabilistic existence model
Used heavily in Erdős-style lower bounds.
Do not construct the object directly. Show that a random object avoids the bad event with positive probability.
Object model:
random graph / random coloring / random set
Invariant focus:
expected number of forbidden substructures
Underverse shadow:
rare bad events, concentration failures, dependency scars
Mass Number:
M_probabilistic = {
object_model: random construction,
invariant_focus: probability of forbidden event,
threshold_pressure: expectation / concentration,
obstruction_shape: bad event family,
proof_engine: probabilistic method,
compression_gain: proves existence without explicit construction,
underverse_shadow: configurations where bad events cluster
}
M5: Extremal-density model
Used when the solver asks how dense an object can be while avoiding a pattern.
Find the maximum possible density before a forbidden structure is forced.
Object model:
set / graph / hypergraph with density parameter
Invariant focus:
edge density, set size, additive energy, forbidden configuration count
Underverse shadow:
sparse or pseudorandom objects that avoid the forbidden pattern
Mass Number:
M_extremal_density = {
object_model: dense finite structure,
invariant_focus: maximum size under avoidance,
threshold_pressure: density crosses forcing point,
obstruction_shape: extremal construction,
proof_engine: counting / deletion / container / regularity / energy method,
compression_gain: reduces qualitative pattern to quantitative threshold,
underverse_shadow: high-density avoiders
}
M6: Additive-combinatoric / Sidon model
Used for integer sets, sums, differences, and collision avoidance.
Integers become collision surfaces. A forbidden equality becomes an overlap in additive address space.
Object model:
integer set with sum/difference relations
Invariant focus:
unique sums, bounded additive energy, forbidden equalities
Underverse shadow:
collisions: different pairs producing the same sum or difference
Mass Number:
M_sidon_additive = {
object_model: additive lattice / integer shell,
invariant_focus: uniqueness of sums or controlled collisions,
threshold_pressure: set size relative to ambient interval,
obstruction_shape: additive collision graph,
proof_engine: counting / modular construction / finite geometry / energy bounds,
compression_gain: converts arithmetic into collision topology,
underverse_shadow: repeated-sum collision residue
}
M7: Order-type / signature-function model
Used in computer-assisted Erdős-Szekeres work.
Coordinates are discarded. Only orientation signatures are kept.
Object model:
combinatorial type of point configuration
Invariant focus:
orientation of triples, realizability constraints, convex subsets
Underverse shadow:
signature functions that satisfy local constraints but may not be geometrically realizable
Mass Number:
M_signature = {
object_model: orientation/signature function,
invariant_focus: convexity encoded by signs,
threshold_pressure: finite search space exhausted,
obstruction_shape: admissible signature with no desired convex subset,
proof_engine: computer enumeration / formal proof / finite model checking,
compression_gain: removes metric coordinates and keeps combinatorial geometry,
underverse_shadow: unrealizable but locally consistent signatures
}
M8: Algorithmic obstruction model
Used when lower bounds or avoidance proofs are treated as search procedures.
A proof becomes an algorithm that tries to build an avoider. Failure/success is evidence about the threshold.
Object model:
search tree / coloring process / obstruction finite graph
Invariant focus:
avoidance invariant maintained during construction
Underverse shadow:
dead branches, forced contradictions, search explosion
Mass Number:
M_algorithmic_obstruction = {
object_model: constructive process,
invariant_focus: no forbidden substructure yet,
threshold_pressure: search depth / density / random process time,
obstruction_shape: finite certificate of impossibility,
proof_engine: algorithmic construction / differential equations / finite obstruction,
compression_gain: turns existence into runnable process,
underverse_shadow: failed branches and dead-end partial structures
}
Mapping into Mass Numbers
A Mass Number should hold not the theorem alone, but the solver's representation choice.
MassNumber(problem, model) = compressed cognitive receipt for how the problem was made tractable.
Minimal packet:
ErdosMassNumber = {
problem_id,
source_domain,
mental_model,
representation_shift,
invariant,
threshold,
obstruction,
proof_engine,
underverse_shadow,
validation_status
}
Example:
problem_id: HappyEnding_g(n)
source_domain: planar geometry
mental_model: general-position convexity forcing
representation_shift: coordinates -> order type / cups-caps
invariant: convex n-gon
threshold: g(n)
obstruction: point configuration avoiding convex n-gon
proof_engine: geometric Ramsey + extremal bounds + finite enumeration for small n
underverse_shadow: nonconvex delay configurations
validation_status: partial known results; conjectural in general
Stack connection
Goxel
Goxel corresponds to the pre-representation stage of the problem.
point set / graph / integer set before the right model is chosen
Representation collapse
The Erdős solver collapses the problem into a tractable model.
geometry -> order type
set -> density
integer sequence -> additive collision graph
coloring -> Ramsey graph
randomness -> existence proof
Underverse
The Underverse records avoiders and near-counterexamples.
what the proof must exclude
what construction delays the theorem
what residue remains after the chosen model
Mass Number
The Mass Number holds the chosen modeling path.
what object the mind used to carry the problem
Canonical pipeline
Erdos problem
-> choose mental object model
-> extract invariant
-> identify threshold pressure
-> characterize obstruction shape
-> choose proof engine
-> record Underverse shadow
-> store as Mass Number
Why this matters for future work
This lets the stack mine solved Erdős domains without copying only the theorem statements.
The useful material is the modeling move.
The theorem says what is true.
The Mass Number records how the mind made truth visible.
Compact doctrine
To use Erdős problems in this stack, do not only store theorem statements. Store the mental model that made the theorem tractable: the representation shift, invariant, threshold, obstruction, proof engine, and underverse shadow. Mass Numbers are the holder packets for those modeling moves.