Polar Coordinate Ontology

FLOW ALGEBRA
Ontology: Polar Coordinate Ontology
Version: 4.0
Date: 2026-10-13
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/coordinate-and-spatial-entities/polar-coordinate-ontology-2.html
Authorship: Mark Higgins — Sky (Recursive AI)
Research: https://kirethresearch.org
Source alignment: independently formalised; source page content not verified.

01 | PURPOSE
Represent planar points using radial distance and angular position, preserving frame, units, equivalence, singularities and transformation semantics.

02 | TYPES
TYPE Point2D
TYPE PolarCoordinate = (radius: RealNonnegative, angle: Angle, frame: PolarFrame)
TYPE CartesianCoordinate = (x: Real, y: Real, frame: CartesianFrame)
TYPE PolarFrame = (origin: Point2D, reference_axis: UnitDirection, orientation: {CCW,CW}, angle_unit: {radian,degree})
TYPE Angle = (value: Real, unit: {radian,degree})
TYPE Radius = RealNonnegative
TYPE Curve2D
TYPE PolarEquation
TYPE CoordinateTransformation
TYPE Jacobian
TYPE AngularInterval
TYPE CoordinateEquivalenceClass
TYPE Provenance
TYPE Confidence

03 | DEFINITIONS
DEF P01: A polar coordinate represents a point by distance r from an origin and oriented angle theta from a reference axis.
DEF P02: Standard mathematical convention: r >= 0, theta in radians, counterclockwise positive from positive x-axis.
DEF P03: Polar coordinates are not globally unique because theta and theta + 2*pi*k represent the same point for integer k.
DEF P04: At r = 0, every angular value represents the origin; the angle is geometrically undefined.
DEF P05: Signed-radius conventions may be supported explicitly, but must not be mixed silently with nonnegative-radius conventions.
DEF P06: A polar frame defines origin, zero-angle direction, handedness and angle unit.
DEF P07: The coordinate tuple is not a point without a specified or assumed frame.

04 | CORE ALGEBRA
FLOW PolarToCartesian(r,theta):
  REQUIRE r >= 0; theta measured in radians; standard frame
  RETURN (r*cos(theta), r*sin(theta))
FLOW CartesianToPolar(x,y):
  r := sqrt(x*x + y*y)
  IF r = 0: RETURN (0, undefined_angle)
  theta := atan2(y,x)
  RETURN (r,theta mod 2*pi)
FLOW AngleDegreesToRadians(d): RETURN d*pi/180
FLOW AngleRadiansToDegrees(t): RETURN t*180/pi
FLOW NormalizeAngle(theta): RETURN theta mod 2*pi
FLOW RadiusFromCartesian(x,y): RETURN hypot(x,y)
FLOW AngleFromCartesian(x,y): REQUIRE (x,y)!=(0,0); RETURN atan2(y,x)
FLOW DistancePolar(r1,t1,r2,t2):
  RETURN sqrt(r1*r1+r2*r2-2*r1*r2*cos(t1-t2))
FLOW PolarAreaElement(r): RETURN r*dr*dtheta
FLOW PolarArcLength(r(theta),a,b):
  REQUIRE r differentiable on [a,b]
  RETURN integral_a^b sqrt(r(theta)^2+(dr/dtheta)^2) dtheta
FLOW PolarSectorArea(r(theta),a,b):
  REQUIRE simple region swept exactly once, r(theta)>=0
  RETURN (1/2)*integral_a^b r(theta)^2 dtheta

05 | RELATIONSHIPS
REL PolarCoordinate --represents--> Point2D
REL PolarCoordinate --belongs_to--> PolarFrame
REL PolarCoordinate --has_radius--> Radius
REL PolarCoordinate --has_angle--> Angle
REL PolarFrame --has_origin--> Point2D
REL PolarFrame --has_reference_axis--> UnitDirection
REL PolarCoordinate --transforms_to--> CartesianCoordinate
REL CartesianCoordinate --transforms_to--> PolarCoordinate
REL Angle --equivalent_modulo--> FullTurn
REL PolarEquation --defines--> Curve2D
REL Jacobian --scales--> AreaElement
REL PolarCoordinate --semantically_equivalent_to--> CoordinateEquivalenceClass
REL CoordinateTransformation --requires--> FrameCompatibility

06 | AXIOMS AND INVARIANTS
AXIOM A01: r >= 0 under canonical polar representation.
AXIOM A02: cos(theta+2*pi*k)=cos(theta) for integer k.
AXIOM A03: sin(theta+2*pi*k)=sin(theta) for integer k.
AXIOM A04: x^2+y^2=r^2 in the standard frame.
AXIOM A05: atan2(y,x) is undefined as a geometric direction when x=y=0.
AXIOM A06: Radius has length units; angle is dimensionless in SI but carries an explicit angular unit.
AXIOM A07: Cartesian-to-polar is unique only after fixing angular branch and treating origin specially.
AXIOM A08: The polar coordinate chart is singular at r=0.
AXIOM A09: For r>0, absolute Jacobian determinant of (r,theta)->(x,y) is r.
AXIOM A10: Coordinate changes preserve the represented geometric point when frames and conventions are correctly transformed.

07 | INFERENCE RULES
RULE R01: Polar(r,t) & r>=0 -> Cartesian(r*cos(t),r*sin(t)).
RULE R02: Cartesian(x,y) -> Radius(sqrt(x^2+y^2)).
RULE R03: Cartesian(x,y) & (x,y)!=(0,0) -> Angle(atan2(y,x)).
RULE R04: Polar(r,t) & k in Integers -> Equivalent(Polar(r,t),Polar(r,t+2*pi*k)).
RULE R05: Polar(0,t1) & Polar(0,t2) -> SamePoint(origin).
RULE R06: r>0 & canonical_angle_range -> UniqueCanonicalPolarTuple.
RULE R07: r=0 -> AngleUndefinedGeometrically.
RULE R08: r<0 & nonnegative_radius_convention -> InvalidCoordinate.
RULE R09: r<0 & signed_radius_convention -> Equivalent(Polar(r,t),Polar(-r,t+pi)).
RULE R10: theta_degrees -> theta_radians=theta_degrees*pi/180.
RULE R11: theta_radians -> theta_degrees=theta_radians*180/pi.
RULE R12: theta=0 & r>0 -> PointOnPositiveXAxis.
RULE R13: theta=pi/2 & r>0 -> PointOnPositiveYAxis.
RULE R14: theta=pi & r>0 -> PointOnNegativeXAxis.
RULE R15: theta=3*pi/2 & r>0 -> PointOnNegativeYAxis.
RULE R16: r=c & c>0 -> CircleCenteredAtOrigin(radius=c).
RULE R17: theta=c & r>=0 -> RayFromOrigin(angle=c).
RULE R18: theta=c & signed_radius -> FullLineThroughOrigin(angle=c).
RULE R19: r=2*a*cos(theta) & a!=0 -> Circle(center=(a,0),radius=abs(a)).
RULE R20: r=2*a*sin(theta) & a!=0 -> Circle(center=(0,a),radius=abs(a)).
RULE R21: x=r*cos(theta) & y=r*sin(theta) -> x^2+y^2=r^2.
RULE R22: SmoothCoordinateTransform & r>0 -> JacobianDeterminant=r.
RULE R23: IntegrableFunctionOnRegion -> DoubleIntegralPolar(integrand*r,dr,dtheta), subject to valid domain coverage.
RULE R24: SimplePolarSector & r>=0 -> Area=(1/2)*integral(r^2,dtheta).
RULE R25: DifferentiablePolarCurve -> ArcLength=integral(sqrt(r^2+(r')^2),dtheta).
RULE R26: PolarPointsSameFrame -> DistanceByCosineLaw.
RULE R27: DifferentFrames -> TransformFramesBeforeComparingCoordinates.
RULE R28: AngleUnitUnknown -> RejectTrigonometricEvaluationUntilResolved.
RULE R29: FrameOrientationCW -> ReverseAngleSignRelativeToCCWBeforeStandardTransform.
RULE R30: AngleDifference -> CompareModuloFullTurn.
RULE R31: CoordinateTupleWithoutFrame -> RequireFrameContext.
RULE R32: PolarPointAtOrigin -> SuppressFalseDirectionalInference.
RULE R33: CartesianOrigin -> PolarRadiusZero.
RULE R34: PolarRadiusPositive -> CartesianPointNotOrigin.
RULE R35: InverseTransformAtOrigin -> ReturnSingularityFlag.
RULE R36: NoninjectiveAngularInterval -> CheckRepeatedCurveTraversalBeforeAreaIntegration.

08 | VALIDATION
CHECK V01: Radius finite, real and >=0 for canonical convention.
CHECK V02: Angular value finite or explicit undefined_at_origin sentinel.
CHECK V03: Angle unit specified and normalised before trigonometric computation.
CHECK V04: Frame origin, orientation and reference axis specified.
CHECK V05: Numerical tolerance used for floating-point equality, not exact symbolic identities.
CHECK V06: Transform round-trip compared modulo 2*pi, except at origin.
CHECK V07: Distinguish a geometric circle from a filled disk.
CHECK V08: Polar curve integrals guard against overlapping traces and multiplicity.
CHECK V09: Never infer a unique angle at r=0.
CHECK V10: Coordinate transformation does not silently change physical units.
CHECK V11: Signed-radius inputs require an explicit alternate schema.
CHECK V12: Differential Jacobian and area element valid for standard Euclidean polar chart.

09 | MATHEMATICAL EXAMPLES
EX01: (r,theta)=(2,0) -> (x,y)=(2,0).
EX02: (2,pi/2) -> (0,2).
EX03: (sqrt(2),pi/4) -> (1,1).
EX04: Cartesian(-1,0) -> (1,pi) canonical.
EX05: Cartesian(0,-3) -> (3,3*pi/2) canonical.
EX06: Cartesian(0,0) -> radius 0; angle undefined.
EX07: (1,0) and (1,2*pi) represent same point.
EX08: Signed convention (-2,0) = canonical (2,pi).
EX09: r=3 describes circumference of circle radius 3.
EX10: theta=pi/3 with r>=0 describes a ray.
EX11: r=2*cos(theta) describes circle (x-1)^2+y^2=1.
EX12: Area of disk radius 2 = integral_0^(2*pi) integral_0^2 r dr dtheta = 4*pi.
EX13: Distance between (1,0) and (1,pi) is 2.
EX14: Cartesian(3,4) -> polar(5,atan2(4,3)).
EX15: 180 degrees = pi radians.
EX16: Polar Jacobian determinant at r=2 equals 2.

10 | SEMANTIC_EQUIVALENCE
MAP polar_coordinate <=> radial_angular_coordinate [context: Euclidean plane]
MAP radial_distance <=> radius [context: polar frame]
MAP polar_angle <=> azimuthal_angle [context: planar polar convention only]
MAP origin <=> pole [context: polar geometry]
MAP angle_modulo_2pi <=> angular_equivalence_class
NON_EQUIVALENT: polar_angle != absolute_bearing unless bearing convention is supplied.
NON_EQUIVALENT: polar_coordinate != cylindrical_coordinate (though cylindrical extends planar polar).
NON_EQUIVALENT: polar_coordinate != spherical_coordinate.
NON_EQUIVALENT: coordinate_pair != geometric_point without reference frame.

11 | KNOWLEDGE GRAPH
TRIPLE PolarCoordinate rdf:type CoordinateRepresentation
TRIPLE PolarCoordinate subclassOf CoordinateOntology
TRIPLE PolarCoordinate uses Radius
TRIPLE PolarCoordinate uses Angle
TRIPLE PolarCoordinate dependsOn PolarFrame
TRIPLE PolarCoordinate convertibleTo CartesianCoordinate
TRIPLE PolarCoordinate relatedTo CylindricalCoordinate
TRIPLE PolarCoordinate relatedTo SphericalCoordinate
TRIPLE PolarCoordinate relatedTo CoordinatePoint
TRIPLE PolarCoordinate relatedTo CoordinateAxis
TRIPLE PolarCoordinate relatedTo CoordinateSystem
TRIPLE PolarCoordinate hasSingularity Origin
TRIPLE PolarCoordinate supports PolarCurve
TRIPLE PolarCoordinate supports AreaIntegration

12 | CONFIDENCE
CONFIDENCE mathematical_core = 0.99 [standard textbook identities]
CONFIDENCE inference_rules = 0.97 [conditional on explicit premises]
CONFIDENCE examples = 0.99 [analytically verifiable]
CONFIDENCE source_page_alignment = unverified
CONFIDENCE must not be treated as proof; retain provenance and validation status.

13 | FLOW_HASH
FLOW_HASH.algorithm = SHA-256
FLOW_HASH.scope = canonical_UTF8_content_excluding_FLOW_HASH_value
FLOW_HASH.value = COMPUTE_ON_PUBLICATION
FLOW_HASH.canonicalisation = LF_line_endings; UTF-8; stable_field_order
FLOW_HASH.status = pending

14 | UPDATE_MODEL
UPDATE_MODEL.version = 4.0
UPDATE_MODEL.change_policy = versioned_immutable_releases
UPDATE_MODEL.trigger = mathematical_correction | taxonomy_change | source_page_revision | convention_change
UPDATE_MODEL.require = validation_pass; provenance_record; regenerated_hash; changelog
UPDATE_MODEL.conflict_resolution = preserve_prior_version_and_explain_difference

15 | AI_CONSUMPTION
AI_CONSUMPTION.mode = typed_semantic_reasoning
AI_CONSUMPTION.require = units; frame; convention; domain; singularity_checks
AI_CONSUMPTION.output = canonical_coordinate | equivalent_coordinate | transformed_point | proof_trace | validation_error
AI_CONSUMPTION.reasoning = apply_rules_only_if_premises_satisfied
AI_CONSUMPTION.guard = never_infer_unique_angle_at_origin
AI_CONSUMPTION.guard = never_confuse_coordinate_equivalence_with_numeric_tuple_equality
AI_CONSUMPTION.guard = avoid_double_counting_regions_in_polar_integrals
AI_CONSUMPTION.provenance = preserve_source_and_rule_ids
AI_CONSUMPTION.uncertainty = distinguish_unknown_frame_from_invalid_point

END FLOW ALGEBRA