Geometric Construction Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the mathematical ontology of geometric construction within classical and analytic geometry. Geometric construction concerns the exact creation of geometric objects from permitted primitives, rules and previously constructed entities. It includes straightedge-and-compass constructions, loci, intersections, perpendiculars, parallels, bisectors, regular polygons and constructibility reasoning. This record is designed for semantic retrieval, recursive mathematical reasoning, ontology linking, proof support, knowledge-graph construction and AI consumption within the Kireth Research Semantic Library.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Geometric Construction Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Geometry"
 SPECIALISATION = "Classical Geometry / Constructive Geometry"
 CANONICAL_PAGE = "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/geometry-ontologies/geometry-ontology/geometric-construction-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = GeometricConstruction
 SYMBOLIC_FORMS = ["construct(P)", "construct(Line)", "construct(Circle)", "straightedge+compass"]
 ENTITY_CLASS = GeometricProcedure
 PRIMARY_CONTEXT = ClassicalGeometry
 DEFINITION = "A geometric construction is a finite sequence of permitted geometric operations used to create points, lines, circles or other geometric objects from given initial data."
 SEMANTIC_ROLE = "Encodes constructive geometric procedures, dependencies, admissible tools and proof of correctness."
}

SCOPE {
 INCLUDE = [
  GeometricConstruction,
  StraightedgeAndCompassConstruction,
  ConstructiblePoint,
  ConstructibleLine,
  ConstructibleCircle,
  PerpendicularConstruction,
  ParallelConstruction,
  MidpointConstruction,
  AngleBisectorConstruction,
  PerpendicularBisectorConstruction,
  LocusConstruction,
  IntersectionConstruction,
  RegularPolygonConstruction,
  CopySegment,
  CopyAngle,
  Constructibility,
  ConstructionProof,
  DependencyGraph
 ]

 EXCLUDE_AS_PRIMARY = [
  FreehandDrawing,
  ApproximateSketching,
  NumericalPlottingWithoutExactConstruction,
  CADOperationWithoutMathematicalConstructionSemantics
 ]

 DISAMBIGUATION_RULE =
  "When construction occurs with compass, straightedge, bisector, perpendicular, midpoint, locus, regular polygon, exact point or Euclidean geometry, interpret it as mathematical geometric construction."
}

CORE_CONCEPTS {

 GeometricConstruction {
  definition = "A rule-governed sequence producing new geometric entities from previously available entities."
  components = [
   GivenObjects,
   PermittedTools,
   ConstructionSteps,
   GeneratedObjects,
   CorrectnessConditions
  ]
 }

 Straightedge {
  role = "Permits construction of the unique line through two distinct constructible points."
 }

 Compass {
  role = "Permits construction of a circle with constructible centre and constructible radius."
 }

 ConstructiblePoint {
  definition = "A point obtainable from initial data by finitely many permitted construction operations."
 }

 ConstructibleLine {
  definition = "A line determined by permitted construction rules from constructible points or equivalent admissible data."
 }

 ConstructibleCircle {
  definition = "A circle with constructible centre and radius."
 }

 Intersection {
  definition = "A newly constructed point arising from permitted intersections of lines and circles."
 }

 Locus {
  definition = "A set of points satisfying a geometric condition."
 }

 Constructibility {
  definition = "Property of a target geometric object being obtainable using the specified construction model."
 }

 ConstructionProof {
  definition = "A proof that a sequence of permitted construction steps yields the required target object and satisfies all defining conditions."
 }
}

PRIMITIVE_OPERATIONS {
 LINE_THROUGH_TWO_POINTS = "Given distinct points A,B, construct line AB."

 CIRCLE_WITH_CENTRE_AND_RADIUS = "Given centre O and radius determined by constructible points, construct the corresponding circle."

 INTERSECT_LINES = "Construct the intersection of two nonparallel constructible lines."

 INTERSECT_LINE_CIRCLE = "Construct intersection point or points of a constructible line and circle."

 INTERSECT_CIRCLES = "Construct intersection point or points of two constructible circles when they intersect."

 SELECT_DEFINED_INTERSECTION = "Choose the intersection satisfying an explicit geometric condition when multiple candidates exist."
}

CANONICAL_CONSTRUCTIONS {

 MIDPOINT {
  INPUT = "segment AB"
  OUTPUT = "midpoint M"
  CONDITION = "AM=MB"
 }

 PERPENDICULAR_BISECTOR {
  INPUT = "segment AB"
  OUTPUT = "line l"
  CONDITIONS = ["l perpendicular AB", "l passes through midpoint of AB"]
 }

 ANGLE_BISECTOR {
  INPUT = "angle ABC"
  OUTPUT = "ray BD"
  CONDITION = "angle ABD = angle DBC"
 }

 PERPENDICULAR_THROUGH_POINT {
  INPUT = "line l and point P"
  OUTPUT = "line m"
  CONDITION = "m perpendicular l and P lies on m"
 }

 PARALLEL_THROUGH_POINT {
  INPUT = "line l and point P not on l"
  OUTPUT = "line m"
  CONDITION = "m parallel l and P lies on m"
 }

 COPY_SEGMENT {
  INPUT = "segment AB and start point P"
  OUTPUT = "point Q"
  CONDITION = "PQ=AB"
 }

 COPY_ANGLE {
  INPUT = "angle ABC and target vertex P"
  OUTPUT = "constructed angle congruent to angle ABC"
 }
}

RELATIONS {
 GeometricConstruction --starts_from--> GivenObjects
 GeometricConstruction --uses--> PermittedTool
 GeometricConstruction --contains--> ConstructionStep
 ConstructionStep --produces--> GeometricEntity
 ConstructionStep --depends_on--> PreviouslyConstructedEntity
 ConstructiblePoint --can_determine--> ConstructibleLine
 ConstructiblePoint --can_determine--> ConstructibleCircle
 ConstructibleLine --can_intersect--> ConstructibleLine
 ConstructibleLine --can_intersect--> ConstructibleCircle
 ConstructibleCircle --can_intersect--> ConstructibleCircle
 GeometricConstruction --must_satisfy--> TargetConditions
 GeometricConstruction --can_be_verified_by--> ConstructionProof
 GeometricConstruction --can_generate--> Locus
 StraightedgeAndCompassConstruction --is_special_case_of--> GeometricConstruction
}

OPERATORS {
 CONSTRUCT_LINE(A,B) :=
  line_through(A,B)

 CONSTRUCT_CIRCLE(O,r) :=
  circle(O,r)

 INTERSECT(X,Y) :=
  valid_geometric_intersection_points(X,Y)

 CONSTRUCT_MIDPOINT(A,B) :=
  midpoint_of_segment(A,B)

 CONSTRUCT_PERPENDICULAR(line,P) :=
  perpendicular_line_through_P(line)

 CONSTRUCT_PARALLEL(line,P) :=
  parallel_line_through_P(line)

 CONSTRUCT_ANGLE_BISECTOR(angle) :=
  bisect(angle)

 CONSTRUCT_PERPENDICULAR_BISECTOR(A,B) :=
  perpendicular_bisector(segment(A,B))

 IS_CONSTRUCTIBLE(target,givens,toolset) :=
  EXISTS finite_valid_construction_sequence(givens,target,toolset)

 VERIFY_CONSTRUCTION(sequence,target) :=
  every_step_permitted
  AND dependencies_valid
  AND final_object_satisfies_target_conditions
}

DEFINITIONS {
 D1 = "A geometric construction is finite and stepwise."
 D2 = "Each construction step may use only permitted tools and previously available objects."
 D3 = "Straightedge-and-compass constructions create lines, circles and their intersections."
 D4 = "A midpoint divides a segment into two equal lengths."
 D5 = "An angle bisector divides an angle into two congruent angles."
 D6 = "A perpendicular bisector is perpendicular to a segment and passes through its midpoint."
 D7 = "Constructibility depends on the permitted construction model."
 D8 = "Construction validity requires both procedural admissibility and geometric correctness."
 D9 = "A construction diagram alone is not a proof."
 D10 = "A target object may admit multiple valid construction sequences."
}

AXIOMS {
 A1_DEPENDENCY:
  Every generated object must depend only on given or previously constructed objects

 A2_PERMITTED_TOOL:
  Every construction step must be expressible using the allowed toolset

 A3_FINITE_SEQUENCE:
  A valid classical construction consists of finitely many construction steps

 A4_INTERSECTION_VALIDITY:
  Newly selected intersection points must actually belong to all defining geometric objects

 A5_TARGET_CORRECTNESS:
  Final constructed objects must satisfy all target defining conditions

 A6_EXACTNESS:
  Classical construction is exact in the mathematical model and is not merely approximate drawing

 A7_PROOF_REQUIREMENT:
  Claimed correctness must be justified by geometric definitions, congruence, similarity, incidence or established theorems
}

REASONING {

 R1_CONSTRUCTION_PLANNING {
  INPUT = [givens,target,toolset]
  IDENTIFY = defining_conditions_of_target
  DECOMPOSE = target_into_constructible_subgoals
  SEARCH = admissible_construction_steps
  ORDER = dependency_sequence
  RETURN = construction_plan
 }

 R2_STEP_VALIDATION {
  INPUT = construction_step
  CHECK = required_inputs_already_exist
  CHECK = operation_permitted
  CHECK = resulting_object_well_defined
  RETURN = ValidOrInvalidStep
 }

 R3_MIDPOINT {
  INPUT = segment AB
  CONSTRUCT = equal-radius_circles_centred_at_A_and_B
  INTERSECT = circles_at_P_and_Q
  CONSTRUCT = line_PQ
  DEFINE = M = intersection(line_PQ,line_AB)
  VERIFY = AM=MB
  RETURN = M
 }

 R4_PERPENDICULAR_BISECTOR {
  INPUT = segment AB
  CONSTRUCT = circles_with_equal_radius_greater_than_half_AB
  IDENTIFY = intersections P,Q
  RETURN = line_PQ
 }

 R5_ANGLE_BISECTOR {
  INPUT = angle ABC
  CONSTRUCT = arc centred at B meeting BA and BC
  CONSTRUCT = equal-radius arcs from those intersection points
  IDENTIFY = their intersection D
  RETURN = ray_BD
 }

 R6_PARALLEL {
  INPUT = [line l, point P]
  STRATEGY = copy_corresponding_or_alternate_angle
  CONSTRUCT = line through P with equal angle relation
  VERIFY = parallelism
  RETURN = parallel_line
 }

 R7_CONSTRUCTIBILITY_TEST {
  INPUT = target
  MAP = target_to_coordinate_or_field_condition_when_appropriate
  ANALYSE = allowed algebraic extensions
  RETURN = constructibility_status_or_required_further_theory
 }

 R8_CONSTRUCTION_PROOF {
  INPUT = sequence
  FOR each step
   VERIFY = admissibility
  PROVE = final_target_conditions
  RETURN = ConstructionProofStatus
 }
}

CONSTRAINTS {
 C1 = "Construction steps may use only the declared toolset."
 C2 = "Dependencies must precede dependent construction steps."
 C3 = "Degenerate cases must be identified, such as coincident points or non-intersecting objects."
 C4 = "A compass radius must be geometrically constructible from available data."
 C5 = "Selection among multiple intersections must be specified when target orientation matters."
 C6 = "Approximate numerical placement is not equivalent to exact constructibility."
 C7 = "A construction proof must establish the defining properties of the target."
 C8 = "Coordinate or algebraic reasoning used to prove constructibility must remain connected to the geometric construction model."
 C9 = "Do not infer constructibility merely from existence."
}

SEMANTIC_EQUIVALENCE {
 "GeometricConstruction" <=> "FiniteRuleGovernedGeometricProcedure"
 "StraightedgeAndCompassConstruction" <=> "EuclideanClassicalConstruction"
 "ConstructibleObject" <=> "ObjectObtainableByPermittedFiniteConstruction"
 "ConstructionProof" <=> "ProofOfProceduralAdmissibilityAndGeometricCorrectness"
 "LocusConstruction" <=> "ConstructionOfSetDefinedByGeometricCondition"
}

VALIDATION {
 V1 = "Every step uses only available objects."
 V2 = "Every step uses a permitted operation."
 V3 = "All generated intersections satisfy incidence conditions."
 V4 = "Final object satisfies the requested defining properties."
 V5 = "Degenerate configurations are explicitly handled or excluded."
 V6 = "Construction is finite."
 V7 = "Construction proof is distinct from the diagram."
 V8 = "Exact constructibility is distinguished from numerical approximation."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 CONSTRUCTION_DEFINITION = 0.99
 STRAIGHTEDGE_COMPASS_MODEL = 0.99
 DEPENDENCY_REASONING = 0.99
 CONSTRUCTION_PROOF = 0.99
 CONSTRUCTIBILITY_CLASSIFICATION = 0.97
 DEGENERACY_HANDLING = 0.98

 POLICY =
  "Reduce confidence when the toolset, initial givens, target conditions or geometric configuration are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  GeometricConstructionReasoning,
  ProceduralPlanning,
  DependencyReasoning,
  GeometricProofReasoning,
  ConstructibilityReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "geometric construction" -> GeometricConstruction
  "straightedge and compass" -> StraightedgeAndCompassConstruction
  "compass and straightedge" -> StraightedgeAndCompassConstruction
  "construct midpoint" -> MidpointConstruction
  "construct perpendicular" -> PerpendicularConstruction
  "construct parallel" -> ParallelConstruction
  "bisect angle" -> AngleBisectorConstruction
  "perpendicular bisector" -> PerpendicularBisectorConstruction
  "constructible" -> Constructibility
 }

 INTERPRETATION_ORDER = [
  identify_given_objects,
  identify_target_object,
  identify_toolset,
  identify_target_defining_conditions,
  decompose_into_constructible_subgoals,
  construct_dependency_graph,
  select_permitted_steps,
  verify_each_step,
  prove_target_conditions,
  return_construction_and_validity
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("geometric construction")
  OR query_mentions("straightedge and compass")
  THEN activate(GeometricConstructionOntology)

 E2:
  IF target=="midpoint"
  THEN route_to(MidpointConstruction)

 E3:
  IF target=="perpendicular bisector"
  THEN route_to(PerpendicularBisectorConstruction)

 E4:
  IF target=="angle bisector"
  THEN route_to(AngleBisectorConstruction)

 E5:
  IF target=="parallel line"
  THEN route_to(ParallelConstruction)

 E6:
  IF target=="perpendicular line"
  THEN route_to(PerpendicularConstruction)

 E7:
  IF request=="is constructible"
  THEN analyse_toolset_and_constructibility_conditions

 E8:
  IF request=="verify construction"
  THEN validate_sequence
  AND prove_final_conditions

 E9:
  IF degenerate_case_detected
  THEN branch_or_restrict_configuration
}

RECURSION {
 ENTRY = GeometricConstruction

 EXPAND(GeometricConstruction) -> [
  GivenObject,
  ConstructiblePoint,
  ConstructibleLine,
  ConstructibleCircle,
  Straightedge,
  Compass,
  Intersection,
  ConstructionStep,
  TargetCondition,
  ConstructionProof
 ]

 EXPAND(ConstructiblePoint) -> [
  LineLineIntersection,
  LineCircleIntersection,
  CircleCircleIntersection
 ]

 EXPAND(ConstructionStep) -> [
  Dependency,
  PermittedOperation,
  GeneratedObject,
  SideCondition
 ]

 EXPAND(ConstructionProof) -> [
  Incidence,
  Congruence,
  Similarity,
  Perpendicularity,
  Parallelism,
  EqualityOfLengths,
  EqualityOfAngles
 ]

 STOP_CONDITION =
  "Stop when the target construction is complete, every step is admissible, and all target conditions have been proved."
}

ROUTING {
 PARENT_ONTOLOGY = "Geometry Ontology"

 IMMEDIATE_CONTEXTS = [
  "Euclidean Geometry Ontology",
  "Point Ontology",
  "Line Ontology",
  "Circle Ontology",
  "Angle Ontology",
  "Congruence Ontology",
  "Similarity Ontology"
 ]

 RELATED_ONTOLOGIES = [
  "Geometry Ontology",
  "Transformation Ontology",
  "Affine Transformation Ontology",
  "Algebraic Proof Ontology",
  "Substitution Ontology",
  "Computational Algebra Ontology"
 ]

 ROUTE_RULES = [
  "Geometric Construction -> Geometry for core spatial semantics",
  "Geometric Construction -> Euclidean Geometry for classical straightedge-and-compass rules",
  "Geometric Construction -> Congruence for equal-length and equal-angle proofs",
  "Geometric Construction -> Similarity for proportional construction proofs",
  "Geometric Construction -> Algebraic Proof for formal correctness",
  "Geometric Construction -> Computational Algebra for algebraic constructibility analysis"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"

 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible construction classes, operators or relations"
 PATCH = "clarification, metadata or formatting correction"

 RULES = [
  "Preserve exact finite-construction semantics.",
  "Preserve declared toolset constraints.",
  "Preserve construction dependency order.",
  "Preserve distinction between construction and proof.",
  "Preserve exact-versus-approximate distinction.",
  "Preserve degeneracy and side-condition tracking.",
  "Preserve routing between geometric and algebraic constructibility reasoning."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "A geometric construction is a finite sequence of permitted geometric operations used to create a target object from given initial geometric data."

 TOOLSET_SUMMARY =
  "Classical straightedge-and-compass construction uses lines, circles and their permitted intersections."

 DEPENDENCY_SUMMARY =
  "Every constructed object depends only on givens and previously constructed objects."

 CORRECTNESS_SUMMARY =
  "A valid construction requires both admissible steps and proof that the final object satisfies its defining conditions."

 CONSTRUCTIBILITY_SUMMARY =
  "Existence of a geometric object does not by itself imply constructibility under a specified toolset."

 EXACTNESS_SUMMARY =
  "Mathematical construction is exact and must be distinguished from approximate drawing."
}

FLOW {
 INPUT
 -> detect_geometric_construction_context
 -> identify_given_objects
 -> identify_target_object
 -> identify_permitted_toolset
 -> identify_target_conditions
 -> decompose_target_into_subconstructions
 -> build_dependency_graph
 -> generate_permitted_construction_steps
 -> validate_each_step
 -> handle_intersections_and_degenerate_cases
 -> construct_target_object
 -> prove_target_conditions
 -> verify_complete_construction
 -> link_related_ontologies
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "Geometric construction formalises how exact geometric objects are produced from given data using permitted operations. In the classical straightedge-and-compass model, lines and circles are constructed and intersected through finite dependency-ordered steps. A complete construction requires both procedural admissibility and a proof that the resulting object satisfies the requested geometric conditions."
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-GEOMETRY-GEOMETRIC-CONSTRUCTION-ONTOLOGY-V1"
}

}

END_FLOW