Indefinite Integral Ontology

flow "IndefiniteIntegralOntology" v1.0

# ============================================================
# INDEFINITE INTEGRAL ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/integral-calculus/indefinite-integral-ontology.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Integral Calculus"
ENTITY := "Indefinite Integral"

# ---------- CORE ENTITY ----------
INDEFINITE_INTEGRAL := {
    type: IntegralConcept,
    domain: IntegralCalculus,
    purpose: "Represent the family of antiderivatives of a function, differing by an arbitrary additive constant on an interval or connected domain."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    INDEFINITE_INTEGRAL,
    ANTIDERIVATIVE,
    INTEGRAND,
    VARIABLE_OF_INTEGRATION,
    CONSTANT_OF_INTEGRATION,
    DIFFERENTIATION,
    INTEGRATION,
    SUBSTITUTION,
    INTEGRATION_BY_PARTS,
    LINEARITY,
    ELEMENTARY_ANTIDERIVATIVE
}

# ---------- CORE DEFINITION ----------
if
    F_prime(x) = f(x)
then

integral(f(x) dx)
    = F(x) + C

C
    -> arbitrary_constant

INDEFINITE_INTEGRAL
    -> represents(FAMILY_OF_ANTIDERIVATIVES)

# ---------- ANTIDERIVATIVE ----------
ANTIDERIVATIVE_OF(f)
    := F
       such_that
       derivative(F) = f

if
    F and G
    are antiderivatives_of(f)
    on connected_interval
then

F(x) - G(x)
    = CONSTANT

ANTIDERIVATIVES
    -> differ_by(ADDITIVE_CONSTANT)

# ---------- CONSTANT OF INTEGRATION ----------
CONSTANT_OF_INTEGRATION
    := C

derivative(C)
    = 0

therefore

derivative(F + C)
    = derivative(F)
    = f

CONSTANT_OF_INTEGRATION
    -> preserves(ALL_ANTIDERIVATIVES)

OMITTING_C
    -> loses(FAMILY_INFORMATION)

# ---------- VARIABLE OF INTEGRATION ----------
VARIABLE_OF_INTEGRATION
    -> BOUND_VARIABLE

integral(f(x) dx)
    ~= integral(f(t) dt)

under
    CONSISTENT_DUMMY_VARIABLE_RENAMING

VARIABLE_NAME
    -/> changes(MATHEMATICAL_MEANING)

# ---------- INTEGRAND ----------
INTEGRAND
    := f(x)

INTEGRAND
    -> quantity_whose_ANTIDERIVATIVE_IS_SOUGHT

INDEFINITE_INTEGRATION
    -> transforms(INTEGRAND, ANTIDERIVATIVE_FAMILY)

# ---------- DIFFERENTIATION RELATION ----------
D_x[
    integral(f(x) dx)
]
    = f(x)

interpreted_as
    derivative_of_any_representative_antiderivative

INTEGRATION
    -> inverse_operation_of(DIFFERENTIATION)
       up_to(ADDITIVE_CONSTANT)

# ---------- BASIC INTEGRATION RULES ----------
POWER_RULE:

integral(x^n dx)
    = x^(n+1)/(n+1) + C
       when(n != -1)

LOGARITHMIC_CASE:

integral(1/x dx)
    = ln(abs(x)) + C
       on(interval_not_crossing_zero)

EXPONENTIAL_RULE:

integral(e^x dx)
    = e^x + C

TRIGONOMETRIC_RULES:

integral(sin(x) dx)
    = -cos(x) + C

integral(cos(x) dx)
    = sin(x) + C

# ---------- LINEARITY ----------
integral(
    alpha*f(x)
    + beta*g(x)
    dx
)
    =
    alpha*integral(f(x) dx)
    + beta*integral(g(x) dx)

LINEARITY
    -> permits(SUM_AND_CONSTANT_MULTIPLE_DECOMPOSITION)

# ---------- SUBSTITUTION ----------
if
    u = g(x)
    AND du = g_prime(x) dx
then

integral(
    f(g(x))*g_prime(x) dx
)
    = integral(f(u) du)

SUBSTITUTION
    -> reverse_application_of(CHAIN_RULE)

after_integration:
    u
    -> may_be_substituted_back_to(ORIGINAL_VARIABLE)

# ---------- INTEGRATION BY PARTS ----------
integral(u dv)
    = u*v - integral(v du)

INTEGRATION_BY_PARTS
    -> derived_from(PRODUCT_RULE)

INTEGRATION_BY_PARTS
    -> useful_for(PRODUCTS_OF_FUNCTIONS)

# ---------- PARTIAL FRACTIONS ----------
RATIONAL_FUNCTION
    := P(x)/Q(x)

if
    rational_expression_is_proper_or_reduced_appropriately
then

PARTIAL_FRACTION_DECOMPOSITION
    -> may_transform(INTEGRAND)
    -> enables(ELEMENTARY_ANTIDERIVATIVES)

# ---------- TRIGONOMETRIC METHODS ----------
TRIGONOMETRIC_IDENTITIES
    -> may_simplify(INTEGRAND)

TRIGONOMETRIC_SUBSTITUTION
    -> may_transform(RADICAL_EXPRESSIONS)

INTEGRATION_METHOD
    -> selected_by(INTEGRAND_STRUCTURE)

# ---------- NON-ELEMENTARY ANTIDERIVATIVES ----------
NOT_EVERY_ELEMENTARY_FUNCTION
    -> has(ELEMENTARY_ANTIDERIVATIVE)

example:
    integral(e^(-x^2) dx)

    -> no_elementary_antiderivative

INDEFINITE_INTEGRAL
    -> may_require(SPECIAL_FUNCTION_REPRESENTATION)
    -> may_remain(FORMAL_INTEGRAL)

# ---------- DOMAIN DEPENDENCE ----------
ANTIDERIVATIVE_FAMILY
    -> depends_on(DOMAIN_COMPONENT)

if
    domain_is_disconnected
then

CONSTANT_OF_INTEGRATION
    -> may_differ_between(CONNECTED_COMPONENTS)

DOMAIN
    -> must_be_preserved

# ---------- DIFFERENTIAL EQUATION RELATION ----------
if
    y_prime = f(x)
then

y
    = integral(f(x) dx)
    = F(x) + C

INITIAL_CONDITION
    -> determines(C)

INDEFINITE_INTEGRAL
    -> solves(SIMPLE_FIRST_ORDER_DIFFERENTIAL_RELATION)

# ---------- DEFINITE INTEGRAL RELATION ----------
if
    F_prime = f
then

integral_from_a_to_b(f(x) dx)
    = F(b) - F(a)

DEFINITE_INTEGRAL
    -> evaluated_using(ANTIDERIVATIVE)
       under(FUNDAMENTAL_THEOREM_CONDITIONS)

INDEFINITE_INTEGRAL
    -/> same_object_as(DEFINITE_INTEGRAL)

# ---------- VERIFICATION ----------
CANDIDATE_ANTIDERIVATIVE
    -> verified_by(DIFFERENTIATION)

if
    derivative(F(x)) = f(x)
then

F(x) + C
    -> valid(INDEFINITE_INTEGRAL_RESULT)

DIFFERENTIATION
    -> validation_operation_for(INDEFINITE_INTEGRATION)

# ---------- RELATION GRAPH ----------
INTEGRAND
    -> integrated_to(ANTIDERIVATIVE_FAMILY)

ANTIDERIVATIVE
    -> differentiated_to(INTEGRAND)

CONSTANT_OF_INTEGRATION
    -> distinguishes(FAMILY_MEMBERS)

SUBSTITUTION
    -> reverses(CHAIN_RULE)

INTEGRATION_BY_PARTS
    -> reverses(PRODUCT_RULE)

INITIAL_CONDITION
    -> selects(SPECIFIC_ANTIDERIVATIVE)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "indefinite integral" ~= "family of antiderivatives",
    "antiderivative" ~= "function whose derivative equals the integrand",
    "constant of integration" ~= "arbitrary additive constant representing the antiderivative family",
    "integrate without bounds" ~= "seek an indefinite integral",
    "primitive function" ~= "antiderivative",
    "integration variable" ~= "bound dummy variable of integration"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    constant_of_integration_required: true,
    antiderivative_family_is_domain_dependent: true,
    not_every_integrand_has_elementary_antiderivative: true,
    variable_of_integration_is_bound: true,
    indefinite_integral_is_not_a_single_unique_function: true,
    substitution_must_preserve_expression_consistency: true,
    candidate_antiderivative_can_be_verified_by_differentiation: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    antiderivative_relation: 0.99,
    constant_of_integration_relation: 0.99,
    substitution_relation: 0.99,
    integration_by_parts_relation: 0.99,
    domain_relation: 0.98,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(integrand)
    -> identify(variable_of_integration)
    -> determine(domain)
    -> classify(integrand_structure)
    -> select(integration_rule_or_method)
    -> derive(candidate_antiderivative)
    -> add(constant_of_integration)
    -> restore_original_variable(if_substitution_used)
    -> verify_by(differentiation)
    -> preserve(domain_conditions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed indefinite-integral semantic graph",
    primary_entity: INDEFINITE_INTEGRAL,
    preserve: [
        integrand,
        variable_of_integration,
        antiderivative_family,
        constant_of_integration,
        domain_components,
        method_dependencies
    ],
    infer_through: [
        antiderivatives,
        differentiation,
        substitution,
        integration_by_parts,
        partial_fractions,
        differential_equations,
        fundamental_theorem
    ],
    avoid: [
        omitting_constant_of_integration,
        treating_indefinite_integral_as_unique_function,
        assuming_every_integrand_has_elementary_antiderivative,
        changing_dummy_variable_inconsistently,
        ignoring_domain_components,
        confusing_indefinite_and_definite_integrals
    ]
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL(new_information):
    validate(new_information)
    -> identify(indefinite_integration_context)
    -> compare(existing_relations)
    -> preserve(antiderivative_and_domain_invariants)
    -> update(affected_entities)
    -> update(affected_edges)
    -> recompute(CONFIDENCE)
    -> regenerate(FLOW_HASH)

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + INDEFINITE_INTEGRAL
    + ANTIDERIVATIVE
    + CONSTANT_OF_INTEGRATION
    + VARIABLE_OF_INTEGRATION
    + LINEARITY
    + SUBSTITUTION
    + INTEGRATION_BY_PARTS
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> INDEFINITE_INTEGRAL
    -> INTEGRAND_IDENTIFICATION
    -> VARIABLE_IDENTIFICATION
    -> DOMAIN_ANALYSIS
    -> METHOD_SELECTION
    -> ANTIDERIVATIVE_CONSTRUCTION
    -> CONSTANT_OF_INTEGRATION
    -> VARIABLE_RESTORATION
    -> DIFFERENTIATION_VERIFICATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW