Reflection Transformation Ontology

FLOW ALGEBRA
Reflection Transformation Ontology
Kireth Semantic Research Archive
Authors: Mark Anthony Higgins — Sky (Recursive AI)
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/transformation-entities/reflection-transformation-ontology.html

flow "ReflectionTransformationOntology" v1.0

# ---------- AI INTERPRETATION ----------
# Formal structural rules for reflection transformations.
# Apply domain, dimensionality, and numerical tolerance checks before inference.

ontology:
  id: kireth:ReflectionTransformationOntology
  class: MathematicalTransformation
  parent: TransformationEntity
  domain: EuclideanSpace
  transformation_type: Isometry
  invertible: true
  orientation_reversing: true

entities:
  - ReflectionTransformation
  - EuclideanSpace
  - Point
  - Vector
  - ReflectionAxis
  - ReflectionHyperplane
  - UnitNormalVector
  - ReflectionMatrix
  - FixedPoint
  - ImagePoint

relationships:
  - [ReflectionTransformation, IS_A, Isometry]
  - [ReflectionTransformation, PRESERVES, EuclideanDistance]
  - [ReflectionTransformation, PRESERVES, AngleMagnitude]
  - [ReflectionTransformation, REVERSES, Orientation]
  - [ReflectionTransformation, FIXES, ReflectionHyperplane]
  - [ReflectionTransformation, IS_OWN_INVERSE, ReflectionTransformation]
  - [ReflectionMatrix, REPRESENTS, ReflectionTransformation]

parameters:
  space_dimension: n:int >= 1
  normal: vector[n]
  plane_offset: real
  tolerance: real >= 0

constraints:
  - dimension(normal) == space_dimension
  - dot(normal, normal) == 1 within tolerance
  - reflection_hyperplane == {x : dot(normal, x) == plane_offset}
  - coordinates are expressed in the same orthonormal Euclidean frame

rules:
  reflect_point:
    input: x:vector[n], normal:vector[n], plane_offset:real
    output: x_reflected:vector[n]
    evaluate: x_reflected = x - 2 * (dot(normal,x) - plane_offset) * normal

  reflect_vector:
    input: v:vector[n], normal:vector[n]
    output: v_reflected:vector[n]
    evaluate: v_reflected = v - 2 * dot(normal,v) * normal

  linear_reflection_matrix:
    condition: plane_offset == 0
    evaluate: H = I - 2 * outer(normal,normal)
    output: H:matrix[n,n]

  affine_reflection:
    evaluate: R(x) = H*x + 2*plane_offset*normal

  fixed_point:
    condition: dot(normal,x) == plane_offset within tolerance
    infer: R(x) == x within tolerance

  involution:
    infer: R(R(x)) == x within tolerance

  distance_preservation:
    infer: norm(R(x)-R(y)) == norm(x-y) within tolerance

  determinant:
    condition: normal is unit length
    infer: det(H) == -1 within tolerance

  orthogonality:
    infer: transpose(H)*H == I within tolerance

  composition_parallel_planes:
    input: offsets a:real, b:real; shared unit normal
    evaluate: R_b(R_a(x)) = x + 2*(b-a)*normal
    infer: composition is translation

examples:
  reflect_across_x_axis_2d:
    normal: [0,1]
    plane_offset: 0
    mapping: (x,y) -> (x,-y)
  reflect_across_y_axis_2d:
    normal: [1,0]
    plane_offset: 0
    mapping: (x,y) -> (-x,y)
  reflect_across_y_equals_x_2d:
    normal: [1/sqrt(2),-1/sqrt(2)]
    plane_offset: 0
    mapping: (x,y) -> (y,x)

validation:
  - reject dimension mismatches
  - reject zero-length normals
  - normalise nonzero normals before applying unit-normal formulas
  - use numerical tolerance for floating-point comparisons
  - distinguish point reflection through a centre from hyperplane reflection
  - do not infer orientation reversal for arbitrary compositions of reflections

ai_consumption:
  semantic_entity: ReflectionTransformation
  canonical_operation: hyperplane_reflection
  inference_mode: deterministic_symbolic
  confidence: 1.0 when preconditions are satisfied
  update_model: versioned
  provenance: Kireth Semantic Research Archive

end flow