Abstraction and the Power of Generalization

Last Updated May 30, 2026

Abstraction is one of the central powers of mathematical thinking. It allows the mind to move beyond a single example, diagram, calculation, or problem and ask what structure is being expressed. A particular triangle becomes the study of triangles. A repeated numerical pattern becomes a recurrence relation. A concrete symmetry becomes a group action. A familiar operation becomes an algebraic structure. A specific network becomes a graph. A local observation becomes a theorem about an entire class of objects.

Generalization is the companion of abstraction. Where abstraction removes unnecessary detail, generalization asks how widely the remaining structure applies. Together, they make mathematics portable. They allow a result discovered in one setting to become a method, theorem, model, or language that travels across many domains.

This article examines abstraction and generalization as disciplined forms of mathematical imagination. They are not vague acts of simplification. They are ways of preserving what matters while deliberately setting aside what does not. The mathematical question is always: what structure survives the removal of detail, and what new insight becomes possible when that structure is named?

What Abstraction Means in Mathematics

In ordinary language, abstraction is sometimes treated as distance from reality. In mathematics, abstraction is more precise. It is the deliberate selection of structure. The mathematician does not simply ignore detail; the mathematician decides which details are irrelevant to the question being asked and which relationships must be preserved.

A triangle drawn on paper has a color, size, thickness of line, position on the page, and physical imperfections. Geometry abstracts from these accidental features and studies the relations among vertices, sides, angles, and transformations. Arithmetic abstracts from the objects being counted. Three apples, three stones, and three stars are different materially, but they share a cardinal structure expressed by the number \(3\). Algebra abstracts further by studying operations and relations independently of any particular numerical system.

Abstraction is therefore not a weakening of thought. It is a strengthening of focus. It asks: what is essential here?

Mathematics becomes powerful because the same abstract structure can appear in many concrete settings. Once the structure is understood, insight becomes transferable. A proof about finite sets may help reason about counting problems. A theorem about groups may apply to symmetries, permutations, modular arithmetic, and transformations. A graph-theoretic result may illuminate transportation networks, proof dependencies, social networks, biological systems, and computational workflows.

Abstraction is not always upward movement toward greater difficulty. Sometimes the strongest abstraction is the simplest representation that preserves the essential relationship. The art lies in choosing the right level of generality. Too little abstraction leaves the thinker trapped in particulars. Too much abstraction may erase the features that make the problem meaningful.

Mathematical abstraction is thus a method of seeing. It teaches the mind to look past surface difference toward preserved relation.

Back to top ↑

Generalization: From Cases to Classes

Generalization begins when a thinker moves from one case to a class of cases. A student first learns that \(2+3=3+2\), then that addition appears to be commutative for many numbers, and eventually that certain operations are commutative while others are not. The shift from a specific example to a general property is a major mathematical move.

But generalization is not merely saying “this works everywhere.” It requires specifying the domain in which the claim holds. A property may hold for natural numbers but fail for matrices. It may hold for finite sets but fail for infinite sets. It may hold for continuous functions but fail for discontinuous ones. It may hold in Euclidean geometry but fail in non-Euclidean geometry.

Strong generalization keeps track of assumptions. It does not simply expand a claim. It asks what conditions make the claim true. This is why mathematical generalization often produces sharper definitions. To know whether something generalizes, one must identify which features of the original example were essential.

For example, the formula for the sum of the first \(n\) positive integers is often introduced through a concrete pattern:

The formula may be motivated by examples, a geometric diagram, pairing terms from opposite ends, or induction. The generalization becomes mathematically legitimate only when the reasoning shows why all cases are covered.

Generalization is therefore both creative and restrictive. It expands the reach of a claim while narrowing its assumptions. This is one of the deepest habits of mathematics: make the statement broad enough to matter, but precise enough to be true.

Back to top ↑

Definitions as Engines of Abstraction

Definitions are among the most powerful tools of abstraction. A mathematical definition selects the properties that will matter and makes them available for reasoning. It is not merely a label. It is a compact theory-building device.

Consider the definition of a group. A group is a set equipped with an operation satisfying closure, associativity, identity, and inverse. This definition abstracts from many concrete situations: integer addition, nonzero rational multiplication, rotations of a polygon, permutations of objects, symmetries of shapes, and transformations in many mathematical systems. The objects may look completely different, yet the same structural conditions allow them to be studied through a common language.

This is one reason mathematical definitions can feel strange at first. They often identify objects by behavior rather than appearance. A number system, space, function, graph, vector space, field, topology, category, or measure is not defined by a picture or material substance, but by structural rules.

Good definitions do several things at once:

• They identify the object of study.
• They preserve the relationships that matter.
• They exclude cases that would break important theorems.
• They include cases that reveal a useful common structure.
• They make proof possible.

A weak definition may be too broad, too narrow, too vague, or too dependent on accidental features. A strong definition opens a field of reasoning. It lets many examples speak through one structure.

Definitions are therefore not passive. They actively shape what can be seen, asked, proved, and generalized.

Back to top ↑

Structure-Preserving Abstraction

The most important abstraction is not the one that removes the most detail. It is the one that preserves the right structure. A map, model, or definition is useful when the relevant relationships remain intact.

This idea appears throughout mathematics. A homomorphism preserves algebraic structure. A continuous function preserves topological structure in a certain sense. An isometry preserves distance. An isomorphism preserves enough structure that two objects can be treated as structurally the same within a given theory. A functor preserves categorical relationships between objects and morphisms. Each of these concepts formalizes a version of the same question: what survives translation from one setting to another?

This is one of the deepest forms of generalization. Instead of asking only what objects are, mathematics asks how objects relate and which relationships remain stable under transformation. A structure-preserving abstraction makes it possible to compare different mathematical worlds without reducing them to identical appearances.

For example, two graphs may have different vertex labels but the same adjacency structure. Two vector spaces may contain different kinds of objects but share the same finite dimension. Two groups may arise from different concrete systems but be isomorphic as algebraic structures. In each case, abstraction separates the essential form from its presentation.

Structure-preserving abstraction also protects against shallow analogy. Two things may look similar without sharing structure. Conversely, two things may look different while being structurally equivalent. Mathematical abstraction teaches the difference.

Back to top ↑

Levels of Abstraction

Mathematics often works through layers of abstraction. Each layer hides some detail and reveals another kind of structure. Understanding a mathematical idea often requires knowing which layer one is working at.

Consider the concept of number. At one level, numbers count objects. At another level, they form systems with operations. Natural numbers, integers, rational numbers, real numbers, complex numbers, and modular number systems all extend or transform earlier number concepts. At a higher level, one may study algebraic structures that include operations resembling addition and multiplication without being ordinary numbers at all.

The same layering appears in geometry. A physical drawing becomes an idealized figure. A figure becomes a set of points satisfying certain relations. Euclidean geometry becomes one instance of geometric structure. Topology abstracts from distance and angle to continuity and connectedness. Differential geometry reintroduces local smooth structure. Algebraic geometry studies geometric objects through algebraic equations. Each layer changes what matters.

The power of abstraction lies partly in moving among these levels. A problem may be difficult at the concrete level but simple at the structural level. Another problem may become too abstract and require a return to examples. Mathematical maturity involves knowing when to ascend, when to descend, and when to translate between levels.

Generalization also changes across levels. A statement may generalize from one number to all numbers, from numbers to algebraic systems, from algebraic systems to categories, or from specific geometric figures to whole classes of spaces. At each step, the thinker must ask whether the original reasoning still works, whether new hypotheses are needed, and whether the generalized statement still says something meaningful.

Back to top ↑

Examples Across Mathematical Domains

Abstraction and generalization appear differently across mathematical domains, but the underlying habit is consistent: identify the structure, remove accidental detail, and ask how broadly the idea travels.

Arithmetic to Algebra

Arithmetic begins with numbers and operations. Algebra abstracts from particular numbers to variables, equations, operations, and structures. The expression \(x+y=y+x\) is not about one pair of numbers. It expresses a property of an operation across a domain. Algebra asks which operations have this property, which do not, and what follows from that difference.

Geometry to Topology

Geometry studies shape, distance, angle, and spatial relation. Topology abstracts away exact distance and angle while preserving continuity, connectedness, compactness, and deformation. A coffee mug and a torus may be treated as structurally similar in topology because each has one hole, even though they are geometrically different.

This is a powerful example of abstraction changing the question. Geometry may ask whether two objects have the same measurements. Topology asks whether one can be continuously transformed into the other without tearing or gluing.

Functions to Transformations

A function may first be understood as a formula. Later it becomes a mapping between sets. In linear algebra, functions become transformations that preserve addition and scalar multiplication. In analysis, functions may be studied by continuity, differentiability, integrability, convergence, or approximation. In category theory, functions become one example of morphisms within a broader theory of structure-preserving arrows.

Networks to Graphs

A transportation system, citation network, theorem dependency map, ecological food web, or software dependency tree may all be represented as a graph. The graph abstraction preserves entities and relationships while setting aside many real-world details. Once represented as a graph, the system can be studied through connectivity, paths, cycles, centrality, components, flow, coloring, or hierarchy.

Proofs to Dependency Structures

A proof is often written as prose, but it has an internal architecture. Definitions support lemmas. Lemmas support propositions. Propositions support theorems. The proof can therefore be abstracted as a dependency graph. This does not capture the full meaning of the proof, but it reveals structural relationships useful for teaching, formalization, proof assistants, and mathematical knowledge organization.

These examples show that abstraction is not one technique. It is a family of practices that appear wherever mathematics seeks the form beneath the instance.

Back to top ↑

Generalization and Proof

Generalization without proof remains conjectural. This is one of the great disciplines of mathematics. A pattern may suggest a general statement, but proof must show why the statement holds for every object in the stated class.

Proof methods often correspond to forms of generalization. Mathematical induction generalizes from a base case and a successor rule to all natural numbers. Direct proof shows that arbitrary elements satisfying the hypotheses also satisfy the conclusion. Proof by contradiction shows that no counterexample can exist under the assumptions. Construction demonstrates general existence by building an object. Structural proof shows that a theorem follows from the defining properties of an abstract object rather than from accidental features.

One of the most important proof habits is the use of an arbitrary object. Instead of proving a claim for a particular triangle, number, function, or group, the mathematician begins: let \(x\) be an arbitrary object satisfying the hypotheses. The proof then avoids using any feature except those guaranteed by the assumptions. If the argument works for the arbitrary object, it works for all objects in the class.

This is a subtle but powerful discipline. It prevents hidden dependence on special cases. It forces the proof to use only the structure specified in the definition. It also reveals whether the theorem can be generalized further. If a proof never uses a certain assumption, the theorem may be stronger than originally stated.

Proof is what distinguishes generalization from extrapolation. Extrapolation says, “it keeps working so far.” Proof says, “it must work under these assumptions.”

Back to top ↑

Counterexample, Boundary, and Failure

Every act of generalization creates a risk: the claim may have been extended too far. Counterexamples are the tools that expose this risk. A counterexample shows that a proposed general statement is false by identifying a single valid case where the conclusion fails.

Counterexamples are not merely negative. They are constructive instruments of mathematical refinement. They teach which assumptions are necessary, which definitions are too broad, and which intuitions are unreliable. A good counterexample does not simply destroy a conjecture. It helps rebuild it in a sharper form.

Boundary cases are especially important. Empty sets, zero values, infinite sets, discontinuous functions, degenerate triangles, disconnected graphs, noncommutative operations, and pathological examples often reveal whether a generalization has been carefully stated. They show where intuition built from familiar cases may fail.

The search for counterexamples is also a form of imagination. It asks what could go wrong, where the definition might stretch, and which case would expose a hidden assumption. In this sense, mathematical creativity is not only the ability to invent generalizations. It is also the ability to test them honestly.

Back to top ↑

Representation and the Cost of Abstraction

Every abstraction has a cost. When a graph represents a transportation network, it may preserve connectivity but ignore travel time, capacity, maintenance, geography, and social context. When an equation models an economy, it may preserve selected relationships while omitting institutional power, inequality, history, or ecological constraint. When a formal proof represents an informal argument, it may preserve logical validity while losing motivation, intuition, and explanatory texture.

This does not mean abstraction is flawed. It means abstraction must be interpreted responsibly. A representation is useful because it selects. But selection also excludes.

Mathematical thinking requires awareness of these costs. A good abstraction is not the one that pretends nothing has been lost. It is the one that makes clear what has been preserved, what has been omitted, and why the representation is appropriate for the question.

This is especially important in applied mathematics, data science, economics, artificial intelligence, public policy, and environmental modeling. In these fields, abstraction does not remain inside a theorem. It may shape decisions that affect people, institutions, ecosystems, and futures. The power of generalization must be joined to the discipline of interpretation.

Back to top ↑

A Mathematical Lens: Equivalence, Mapping, and Invariance

A useful lens for understanding abstraction is the relationship among equivalence, mapping, and invariance. These concepts appear throughout mathematics because they formalize how structure survives transformation.

An equivalence relation groups objects that should be treated as the same for a particular purpose. Equality may be too strict. Two fractions, \(1/2\) and \(2/4\), are not the same symbolic expression, but they represent the same rational number. Two geometric figures may not be identical in position but may be congruent. Two graphs may use different labels but have the same adjacency structure.

Mapping is the act of sending objects from one setting to another. A structure-preserving map makes abstraction reliable because it respects the relations being studied. If the relevant structure is not preserved, the map may be misleading.

Invariance asks what remains unchanged under allowable transformations. An invariant allows classification, comparison, and proof. For example, a graph’s degree sequence remains unchanged under relabeling of vertices. A topological invariant remains unchanged under continuous deformation. An algebraic invariant may distinguish structures that look superficially similar.

From this lens, abstraction is not the disappearance of detail. It is the construction of a disciplined sameness relation. It tells us what differences we are allowed to ignore because the structure under study is preserved.

Back to top ↑

Computational Companion Examples

The companion repository for this article should extend the Mathematical Thinking codebase with examples focused on abstraction, equivalence relations, invariant computation, structure-preserving maps, and generalization testing. The examples below are compact article-level previews; the repository can expand them into richer cross-language workflows.

Python: Equivalence Classes and Invariants

from dataclasses import dataclass
from math import gcd
from collections import Counter

@dataclass(frozen=True)
class Fraction:
    numerator: int
    denominator: int

    def normalized(self) -> tuple[int, int]:
        if self.denominator == 0:
            raise ValueError("Denominator cannot be zero.")
        sign = -1 if self.denominator < 0 else 1
        n = self.numerator * sign
        d = self.denominator * sign
        g = gcd(abs(n), abs(d))
        return (n // g, d // g)

def equivalent_fraction_classes(values: list[Fraction]) -> dict[tuple[int, int], list[Fraction]]:
    classes: dict[tuple[int, int], list[Fraction]] = {}
    for value in values:
        key = value.normalized()
        classes.setdefault(key, []).append(value)
    return classes

def degree_sequence(edges: list[tuple[str, str]]) -> tuple[int, ...]:
    counts = Counter()
    for a, b in edges:
        counts[a] += 1
        counts[b] += 1
    return tuple(sorted(counts.values(), reverse=True))

fractions = [Fraction(1, 2), Fraction(2, 4), Fraction(3, 6), Fraction(2, 3)]
print(equivalent_fraction_classes(fractions))

cycle = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "a")]
renamed_cycle = [("w", "x"), ("x", "y"), ("y", "z"), ("z", "w")]

print(degree_sequence(cycle))
print(degree_sequence(renamed_cycle))
print(degree_sequence(cycle) == degree_sequence(renamed_cycle))

R: Generalization Testing from Generated Cases

sum_first_n <- function(n) {
  sum(seq_len(n))
}

general_formula <- function(n) {
  n * (n + 1) / 2
}

test_generalization <- function(max_n) {
  data.frame(
    n = 1:max_n,
    computed_sum = sapply(1:max_n, sum_first_n),
    formula_value = sapply(1:max_n, general_formula),
    agrees = sapply(1:max_n, sum_first_n) == sapply(1:max_n, general_formula)
  )
}

results <- test_generalization(25)
print(results)

if (all(results$agrees)) {
  cat("The tested cases support the conjecture, but do not replace proof.\n")
}

Julia: Structure-Preserving Maps

struct ModElement
    value::Int
    modulus::Int
end

function normalize(x::ModElement)
    return mod(x.value, x.modulus)
end

function add_mod(a::ModElement, b::ModElement)
    if a.modulus != b.modulus
        error("Moduli must match.")
    end
    return ModElement(a.value + b.value, a.modulus)
end

function preserves_addition(f, a::ModElement, b::ModElement)
    left = f(add_mod(a, b))
    right = add_mod(f(a), f(b))
    return normalize(left) == normalize(right)
end

double_map(x::ModElement) = ModElement(2 * x.value, x.modulus)

a = ModElement(3, 7)
b = ModElement(5, 7)

println(preserves_addition(double_map, a, b))

SQL: Abstraction, Generalization, and Invariant Metadata

CREATE TABLE abstraction (
  abstraction_id TEXT PRIMARY KEY,
  name TEXT NOT NULL,
  source_context TEXT NOT NULL,
  preserved_structure TEXT NOT NULL,
  omitted_detail TEXT NOT NULL
);

CREATE TABLE generalization (
  generalization_id TEXT PRIMARY KEY,
  abstraction_id TEXT NOT NULL,
  claim TEXT NOT NULL,
  domain TEXT NOT NULL,
  required_assumptions TEXT NOT NULL,
  proof_status TEXT NOT NULL,
  FOREIGN KEY (abstraction_id) REFERENCES abstraction(abstraction_id)
);

CREATE TABLE invariant (
  invariant_id TEXT PRIMARY KEY,
  name TEXT NOT NULL,
  object_class TEXT NOT NULL,
  transformation_class TEXT NOT NULL,
  description TEXT NOT NULL
);

CREATE TABLE counterexample (
  counterexample_id TEXT PRIMARY KEY,
  generalization_id TEXT NOT NULL,
  object_description TEXT NOT NULL,
  failure_mode TEXT NOT NULL,
  lesson TEXT NOT NULL,
  FOREIGN KEY (generalization_id) REFERENCES generalization(generalization_id)
);

Haskell: Typed Abstraction, Equivalence, and Generalization Records

Haskell is useful for this article because abstraction and generalization depend on careful distinctions: an example is not a class, an equivalence relation is not ordinary equality, a conjecture is not a proof, and a structure-preserving map is not merely any function. Algebraic data types make these distinctions explicit. They allow a computational scaffold to represent abstraction level, proof status, preserved structure, omitted detail, and responsible review questions without collapsing them into undifferentiated text.

{-# OPTIONS_GHC -Wall #-}

module Main where

data AbstractionLevel
  = Concrete
  | Numerical
  | Algebraic
  | Structural
  | Categorical
  deriving (Eq, Show)

data ProofStatus
  = ExampleObserved
  | PatternDetected
  | Conjectured
  | Proved
  | RefutedByCounterexample
  | RequiresReview
  deriving (Eq, Show)

data StructurePreserved
  = Cardinality
  | OperationLaw
  | Adjacency
  | Distance
  | Continuity
  | EquivalenceClass
  | Composition
  deriving (Eq, Show)

data AbstractionRecord = AbstractionRecord
  { recordName :: String
  , sourceContext :: String
  , abstractionLevel :: AbstractionLevel
  , preservedStructure :: StructurePreserved
  , omittedDetail :: String
  , proofStatus :: ProofStatus
  , reviewQuestion :: String
  } deriving (Eq, Show)

records :: [AbstractionRecord]
records =
  [ AbstractionRecord
      "three apples to the number three"
      "counting concrete objects"
      Numerical
      Cardinality
      "material identity, color, location, and physical difference"
      Proved
      "Does the abstraction preserve the counting structure needed for the argument?"
  , AbstractionRecord
      "fractions as rational equivalence classes"
      "different symbolic fractions such as 1/2 and 2/4"
      Structural
      EquivalenceClass
      "surface notation and numerator-denominator presentation"
      Proved
      "Which relation determines when different expressions represent the same rational number?"
  , AbstractionRecord
      "network as graph"
      "transportation, citation, proof, or software dependency network"
      Structural
      Adjacency
      "travel time, institutional history, weight, and context unless separately encoded"
      RequiresReview
      "Does the graph preserve the relation that matters, or has the abstraction omitted essential meaning?"
  , AbstractionRecord
      "group as operation structure"
      "symmetries, permutations, modular arithmetic, and transformations"
      Algebraic
      OperationLaw
      "the concrete nature of the elements"
      Proved
      "Do the operation laws rather than the element labels carry the reasoning?"
  ]

main :: IO ()
main = do
  putStrLn "Abstraction and generalization records:"
  mapM_ print records

This Haskell treatment strengthens the article’s computational layer because it gives abstraction a typed vocabulary. It distinguishes levels of abstraction, kinds of preserved structure, and proof status. That matters because abstraction is powerful only when the preserved structure is named and the omitted detail is acknowledged.

These examples show how computational artifacts can support mathematical thinking without replacing proof. Code can generate cases, organize examples, test conjectures, compute invariants, and expose structure. But the mathematical status of a generalization still depends on the reasoning that justifies it.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-thinking workspace focused on abstraction, generalization, equivalence, invariance, structure-preserving maps, counterexample search, and proof-oriented metadata.

Back to top ↑

Abstraction, Modeling, and Responsibility

Abstraction is essential to mathematics, science, and modeling. But in applied settings, abstraction also carries ethical responsibility. When a model abstracts from reality, it preserves some relationships and omits others. Those omissions matter.

A public policy model may abstract people into variables. An economic model may abstract institutions into equations. A machine learning system may abstract human behavior into training data and classifications. An environmental model may abstract ecosystems into measurable indicators. These abstractions can be useful, but they can also conceal uncertainty, inequality, power, historical context, ecological complexity, or moral harm.

The ethical question is not whether abstraction should be avoided. Without abstraction, complex reasoning would be impossible. The question is whether the abstraction is honest about what it preserves, what it omits, and what consequences follow from using it.

Mathematical abstraction should make reasoning clearer, not make accountability disappear. The same discipline that asks “what structure is preserved?” should also ask “what reality has been left out?”

Responsible generalization requires humility. A theorem may hold universally within a formal system. A model rarely holds universally in the world. Applied abstraction must therefore be interpreted through evidence, context, uncertainty, and ethical judgment.

Back to top ↑

Why Abstraction and Generalization Matter

Abstraction and generalization matter because they make deep understanding possible. Without abstraction, every problem remains isolated. Without generalization, every solution remains local. Mathematics becomes powerful when insight can travel from one example to a class, from one representation to another, from one domain to many domains.

These habits are central not only to pure mathematics, but also to science, engineering, computer science, economics, artificial intelligence, systems modeling, philosophy, and public reasoning. A climate model abstracts from the full complexity of Earth systems. A proof assistant abstracts mathematical claims into formal languages. A database abstracts real-world entities into schemas. A graph abstracts relationships into vertices and edges. A statistical model abstracts observed data into distributions, parameters, and uncertainty.

In each case, the question is not simply whether the abstraction is elegant. The question is whether it preserves the structure needed for the task, whether its assumptions are clear, whether its generalizations are justified, and whether its limitations are understood.

The power of abstraction is the power to see what different things have in common. The power of generalization is the power to extend insight beyond the first case. Together, they form one of the deepest capacities of mathematical thought: the ability to move from the particular to the structural without losing the discipline of proof.

Mathematics begins with examples, but it does not remain there. It asks what can be carried forward, what can be named, what can be transformed, what can be proved, and what can be responsibly applied. That is the power of abstraction and generalization.

Back to top ↑

Related Articles

• What Is Mathematical Thinking? Pattern, Proof, Architecture, and Reason
• Patterns, Structure, and the Mathematical Imagination
• Mathematics as the Science of Patterns
• Proof and the Logic of Mathematical Justification
• Logic and the Structure of Formal Inference
• Symbols, Language, and Mathematical Representation
• Sets, Relations, and Functions as Modes of Thought
• Mathematical Thinking and Category-Level Abstraction
• Mathematical Thinking and Scientific Modeling
• Mathematical Thinking and the Ethics of Quantification

Further Reading

• Awodey, S. (2010) Category Theory. 2nd edn. Oxford: Oxford University Press. Available at: https://global.oup.com/academic/product/category-theory-9780199237180
• Courant, R. and Robbins, H. (1996) What Is Mathematics? An Elementary Approach to Ideas and Methods. 2nd edn. Oxford: Oxford University Press. Available at: https://global.oup.com/academic/product/what-is-mathematics-9780195105193
• Devlin, K. (2012) Introduction to Mathematical Thinking. Stanford University / Coursera course materials and related publications. Available at: https://web.stanford.edu/~kdevlin/
• Lakatos, I. (1976) Proofs and Refutations: The Logic of Mathematical Discovery. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/core/books/proofs-and-refutations/3B5BDF18C7A5F4E7D4B30F06E4E5A0F1
• Mac Lane, S. (1998) Categories for the Working Mathematician. 2nd edn. New York: Springer. Available at: https://link.springer.com/book/10.1007/978-1-4757-4721-8
• Pólya, G. (1945) How to Solve It: A New Aspect of Mathematical Method. Princeton: Princeton University Press. Available at: https://press.princeton.edu/books/paperback/9780691164076/how-to-solve-it

Back to top ↑

References

• Awodey, S. (2010) Category Theory. 2nd edn. Oxford: Oxford University Press. Available at: https://global.oup.com/academic/product/category-theory-9780199237180
• Courant, R. and Robbins, H. (1996) What Is Mathematics? An Elementary Approach to Ideas and Methods. 2nd edn. Oxford: Oxford University Press. Available at: https://global.oup.com/academic/product/what-is-mathematics-9780195105193
• Devlin, K. (2012) Introduction to Mathematical Thinking. Stanford University / Coursera course materials and related publications. Available at: https://web.stanford.edu/~kdevlin/
• Hadamard, J. (1945) The Psychology of Invention in the Mathematical Field. Princeton: Princeton University Press. Available at: https://press.princeton.edu/books/paperback/9780691029313/the-psychology-of-invention-in-the-mathematical-field
• Hardy, G.H. (1940) A Mathematician’s Apology. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/core/books/mathematicians-apology/6F0C29793C928E41F9A7E5C3E7A413C3
• Lakatos, I. (1976) Proofs and Refutations: The Logic of Mathematical Discovery. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/core/books/proofs-and-refutations/3B5BDF18C7A5F4E7D4B30F06E4E5A0F1
• Mac Lane, S. (1998) Categories for the Working Mathematician. 2nd edn. New York: Springer. Available at: https://link.springer.com/book/10.1007/978-1-4757-4721-8
• Pólya, G. (1945) How to Solve It: A New Aspect of Mathematical Method. Princeton: Princeton University Press. Available at: https://press.princeton.edu/books/paperback/9780691164076/how-to-solve-it

Back to top ↑