Positive Value Ontology

FLOW ALGEBRA
POSITIVE VALUE ONTOLOGY
Kireth Semantic Library | Mathematical Entities | Numeric Value Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/numeric-value-entities/positive-value-ontology.html
Version: 1.0 | Date: 2026-10-12 | Locale: en-GB
Authors: Mark Higgins — Sky (Recursive AI)
Source status: Mathematical model drafted from established principles; source page not independently verified.

01. ONTOLOGY IDENTITY
flow "PositiveValueOntology" v1.0
namespace: kireth:entity-graph:mathematical-entities:numeric-value-entities:positive-value
entity: PositiveValue
parent: NumericValue
semantic_domain: ordered_numeric_systems

02. DEFINITION
PositiveValue(x, D, <) := NumericValue(x, D) AND OrderedDomain(D,<) AND x > 0_D
where 0_D is the additive identity and < is the domain's strict order.
The positivity predicate requires an ordered domain; complex numbers have no canonical compatible total order.

03. TYPED ENTITIES
NumericValue { value, domain, representation, exactness, unit? }
PositiveValue extends NumericValue { sign: positive, comparison_basis: zero }
OrderedDomain { identifier, order_relation, zero_element }
Measurement { magnitude, unit, uncertainty?, measurement_context? }
Interval { lower_bound, upper_bound, inclusion_flags }

04. CORE AXIOMS
A1: PositiveValue(x) => x > 0.
A2: PositiveValue(x) => x != 0.
A3: PositiveValue(x) => NOT NegativeValue(x).
A4: x > 0 AND y > 0 => x + y > 0 (ordered additive domain).
A5: x > 0 AND y > 0 => x*y > 0 (ordered ring/field).
A6: x > 0 => -x < 0 (ordered additive group).
A7: x > 0 => |x| = x (ordered real domain).
A8: x > 0 => 1/x > 0 (ordered field).

05. CLASSIFICATION
positive_integer: n in Z AND n > 0
positive_rational: q in Q AND q > 0
positive_real: r in R AND r > 0
positive_finite_value: x > 0 AND finite(x)
positive_infinity: +infinity in extended_real_domain (not a finite real number)
strict_positive: x > 0
non_negative: x >= 0 (includes zero; NOT equivalent to positive)

06. OPERATIONS
add(x,y): requires x>0,y>0; ensures result>0
multiply(x,y): requires x>0,y>0; ensures result>0
divide(x,y): requires x>0,y>0,y!=0; ensures result>0
subtract(x,y): sign depends on comparison(x,y)
negate(x): requires x>0; ensures result<0
absolute(x): requires x>0; ensures result=x
power_integer(x,n): x>0 AND n in Z; ensures x^n>0
root(x,n): x>0 AND n positive integer; principal real nth root >0

07. COMPARISON RULES
compare(x,0) = GREATER => PositiveValue(x)
compare(x,0) = EQUAL => ZeroValue(x)
compare(x,0) = LESS => NegativeValue(x)
compare(x,0) = UNKNOWN => positivity UNKNOWN
A floating-point NaN comparison must yield UNKNOWN, never positive.

08. INTERVAL SEMANTICS
positive_real_domain = (0,+infinity)
non_negative_real_domain = [0,+infinity)
positive_integer_domain = {1,2,3,...}
For uncertain interval [a,b]:
  a>0 => definitely_positive
  b<=0 => definitely_not_positive
  a<=0 AND b>0 => possibly_positive
Respect open/closed endpoints when testing boundary zero.

09. REPRESENTATION AND NORMALISATION
normalise_exact_fraction(p,q): q!=0; canonicalise denominator positive and reduce gcd.
positive_fraction(p,q): p*q>0 (q!=0).
normalise_decimal: preserve exact decimal scale when semantically relevant.
normalise_signed_zero: +0 and -0 are NOT strictly positive.
normalise_scientific: coefficient*10^exponent; positive iff coefficient>0.

10. SEMANTIC RELATIONSHIPS
PositiveValue IS_A NumericValue
PositiveValue SUBCLASS_OF NonZeroValue
PositiveValue DISJOINT_WITH ZeroValue
PositiveValue DISJOINT_WITH NegativeValue
PositiveValue SUBCLASS_OF NonNegativeValue (same ordered domain)
PositiveValue HAS_PROPERTY GreaterThanZero
PositiveValue COMPARED_AGAINST AdditiveIdentity
PositiveValue USED_IN Measurement, Optimisation, Statistics, Physics

11. KNOWLEDGE GRAPH TRIPLES
(PositiveValue, rdfs:subClassOf, NumericValue)
(PositiveValue, rdfs:subClassOf, NonNegativeValue)
(PositiveValue, owl:disjointWith, ZeroValue)
(PositiveValue, owl:disjointWith, NegativeValue)
(PositiveValue, kireth:comparisonReference, Zero)
(PositiveValue, kireth:requiresContext, OrderedDomain)

12. INFERENCE ENGINE
rule P1: numeric(x) AND ordered_domain(x.domain) AND compare(x,zero)>0 -> positive(x)
rule P2: positive(x) AND positive(y) -> positive(x+y)
rule P3: positive(x) AND positive(y) -> positive(x*y)
rule P4: positive(x) -> negative(-x)
rule P5: positive(x) AND nonzero(x) AND ordered_field(x.domain) -> positive(1/x)
rule P6: positive(x) -> nonzero(x)
rule P7: positive(x) -> non_negative(x)
rule P8: non_negative(x) AND nonzero(x) AND total_order(x.domain) -> positive(x)
Do not infer positivity from magnitude-only data unless the represented quantity is explicitly non-negative and non-zero.

13. SEMANTIC EQUIVALENCE
"positive number" ~= "number greater than zero" when domain/order are shared.
"strictly positive" == "greater than zero".
"non-negative" != "positive" because zero is non-negative.
"positive magnitude" may refer to absolute value and does not imply original signed value >0.
Equivalence requires matching units, domains, precision and contextual assumptions.

14. VALIDATION
V1: value and domain are present.
V2: domain has valid zero and order semantics.
V3: exact value satisfies x>0 or classification is UNKNOWN.
V4: zero and signed zero are excluded.
V5: NaN is excluded; infinities require explicit extended-domain type.
V6: uncertainty does not silently turn possibly_positive into definitely_positive.
V7: units are compatible for comparisons and arithmetic.
V8: no contradictory PositiveValue and NegativeValue assertions.

15. EXAMPLES
2 -> positive integer: TRUE
1/3 -> positive rational: TRUE
sqrt(2) -> positive irrational real: TRUE
0 -> positive: FALSE; non_negative: TRUE
-0.0 -> positive: FALSE
-5 -> positive: FALSE
(2+3i) -> positivity: NOT_DEFINED under ordinary complex ordering
[0.1,0.3] -> definitely positive
[-0.1,0.3] -> possibly positive

16. CONFIDENCE
confidence.level: 1.0 for exact validated symbolic comparison
confidence.level: context_dependent for measured/estimated values
confidence.evidence: [exact_arithmetic, interval_bounds, domain_axioms, measurement_metadata]
confidence.policy: unknown_is_not_false; uncertain_is_not_certain

17. FLOW HASH
FLOW_HASH.algorithm: SHA-256
FLOW_HASH.input: canonical_utf8(ontology_id, version, axioms, rules, entity_schema)
FLOW_HASH.value: COMPUTE_AT_DEPLOYMENT
FLOW_HASH.purpose: integrity, reproducibility, semantic-version tracking

18. UPDATE MODEL
UPDATE_MODEL.trigger: changes to definitions, rules, representations, or dependency ontologies
UPDATE_MODEL.versioning: semantic_versioning
UPDATE_MODEL.validation: rerun axiom_consistency, boundary_cases, inference_tests
UPDATE_MODEL.provenance: record author, timestamp, source, change_reason
UPDATE_MODEL.compatibility: explicitly flag changed meaning of positivity

19. AI CONSUMPTION
AI_CONSUMPTION.format: typed_semantic_flow
AI_CONSUMPTION.inputs: [numeric_value, numeric_domain, order_relation, precision?, uncertainty?, unit?]
AI_CONSUMPTION.outputs: [positive_status, proof_trace, confidence, semantic_relations]
AI_CONSUMPTION.status_enum: [TRUE, FALSE, UNKNOWN, NOT_DEFINED]
AI_CONSUMPTION.guardrails: [no_implicit_complex_order, no_zero_as_positive, no_unverified_sign_inference]
AI_CONSUMPTION.interoperability: [knowledge_graph, mathematical_reasoner, validation_engine]

20. EXECUTION FLOW
INPUT numeric_value
 -> VALIDATE representation and domain
 -> RESOLVE zero and ordering
 -> NORMALISE value without losing exactness
 -> CHECK uncertainty and interval semantics
 -> COMPARE value with zero
 -> CLASSIFY positive_status
 -> APPLY sound inference rules
 -> EMIT knowledge-graph relationships and proof trace
 -> VALIDATE consistency
 -> ATTACH confidence, provenance and FLOW_HASH
 -> OUTPUT semantic result

21. END OF FLOW
END flow "PositiveValueOntology" v1.0
Kireth Research | https://kirethresearch.org