examples-v0_10.sql

-- =============================================================
-- Common Knowledge KB — Interactive Examples (v0.10)
-- =============================================================
-- Demonstrates schema, predicates, and objects kernel usage.
-- Run after all three kernel files in order:
--   1. common_knowledge_schema.sql
--   2. common_predicates_kernel.sql
--   3. common_objects_kernel.sql
--
-- Parts:
--   A  Inspection of kernel state
--   B  Simple queries on kernel content
--   C  Inserting individuals and asserting facts
--   D  Temporal queries (holds_at)
--   E  Bayesian belief and trust updates
--   F  Derived statements and provenance
--   G  Conflict detection and resolution
--   H  Aggregate views and introspection
--   I  Enforcement demonstrations (v0.8/v0.9 trigger layer)
--   J  validate_kb_integrity and truth_status
--   K  Python reference (psycopg2 patterns)
-- =============================================================


-- ════════════════════════════════════════════════════════════
-- PART A: INSPECTION
-- ════════════════════════════════════════════════════════════

-- ── A1. Object counts by kind ────────────────────────────────

SELECT kind, count(*) AS n
FROM objects
GROUP BY kind
ORDER BY n DESC;


-- ── A2. All basis predicates — arity, strictness, inverse ────

SELECT
    o.canonical_name            AS predicate,
    p.arity,
    CASE p.arity
        WHEN 1 THEN 'unary'
        WHEN 2 THEN 'binary'
        WHEN 3 THEN 'ternary'
        ELSE        'higher-order'
    END                         AS arg_structure,
    p.arg_labels,
    p.domain_strictness,
    CASE WHEN p.inverse_predicate_id IS NOT NULL
         THEN inv.canonical_name
         ELSE NULL
    END                         AS inverse,
    p.nl_description
FROM predicates p
JOIN objects o ON o.id = p.id
LEFT JOIN objects inv ON inv.id = p.inverse_predicate_id
WHERE p.is_basis = true
ORDER BY p.arity, o.canonical_name;
-- Expect: before/after, part_of/has_part, contains/part_of show inverse names.


-- ── A3. Full type hierarchy with effective belief ────────────

SELECT
    child.canonical_name                       AS subtype,
    parent.canonical_name                      AS supertype,
    round(seb.effective_mean::numeric, 4)      AS effective_belief,
    round(seb.raw_mean::numeric, 4)            AS raw_belief,
    s.t_kind,
    s.statement_kind
FROM statements s
JOIN statement_effective_belief seb ON seb.id     = s.id
JOIN objects child                  ON child.id   = s.object_args[1]
JOIN objects parent                 ON parent.id  = s.object_args[2]
WHERE s.predicate_id = stable_uuid('subtype_of', 'predicate')
ORDER BY parent.canonical_name, child.canonical_name;


-- ── A4. All disjointness axioms with kind and effective belief ─
-- 27 constraint axioms (hard; trg_za enforces at is_a time).
-- 3 incompatibility axioms (graded; scales competition model).

SELECT
    a.canonical_name                           AS type_a,
    b.canonical_name                           AS type_b,
    s.disjointness_kind,
    round(seb.effective_mean::numeric, 4)      AS effective_belief,
    s.statement_kind
FROM statements s
JOIN statement_effective_belief seb ON seb.id = s.id
JOIN objects a                      ON a.id   = s.object_args[1]
JOIN objects b                      ON b.id   = s.object_args[2]
WHERE s.predicate_id = stable_uuid('disjoint_with', 'predicate')
ORDER BY s.disjointness_kind, type_a, type_b;
-- Expect: 30 rows total; all statement_kind = 'ontological'.
-- constraint rows ≈ 1.0 belief; incompatibility rows 0.7–0.9.


-- ── A5. Source credibility priors ────────────────────────────

SELECT
    o.canonical_name                          AS source,
    c.canonical_name                          AS context,
    round(scs.mean::numeric, 4)               AS credibility_mean,
    round(scs.ci_low::numeric, 4)             AS ci_low,
    round(scs.ci_high::numeric, 4)            AS ci_high,
    round(scs.evidence_strength::numeric, 1)  AS evidence_strength,
    scs.is_protected
FROM source_credibility_score scs
JOIN objects o ON o.id = scs.source_id
JOIN objects c ON c.id = scs.context_id
ORDER BY scs.mean DESC;


-- ── A6. type_membership cache ─────────────────────────────────
-- Populated by trg_sync_type_membership on is_a/instance_of inserts;
-- never written directly.

SELECT
    obj.canonical_name  AS object,
    typ.canonical_name  AS type,
    round((tm.alpha / (tm.alpha + tm.beta))::numeric, 4) AS belief
FROM type_membership tm
JOIN objects obj ON obj.id = tm.object_id
JOIN objects typ ON typ.id = tm.type_id
ORDER BY obj.canonical_name, typ.canonical_name;


-- ── A7. Role subtypes ─────────────────────────────────────────
-- mathematician, programmer, inventor etc. seeded as subtype_of(X, role)
-- in common_objects_kernel.sql. is_a rows are NOT inserted — subtype_of
-- combined with recursive-CTE domain enforcement is sufficient, and
-- parallel is_a rows would cause type/instance punning.

SELECT
    child.canonical_name                       AS role_subtype,
    parent.canonical_name                      AS parent,
    round(seb.effective_mean::numeric, 4)      AS belief,
    s.statement_kind
FROM statements s
JOIN statement_effective_belief seb ON seb.id     = s.id
JOIN objects child                  ON child.id   = s.object_args[1]
JOIN objects parent                 ON parent.id  = s.object_args[2]
WHERE s.predicate_id        = stable_uuid('subtype_of', 'predicate')
  AND parent.canonical_name = 'role'
ORDER BY child.canonical_name;
-- Expect: artist, engineer, inventor, mathematician, politician,
--         programmer, scientist, teacher — all belief ≈ 1.0,
--         statement_kind = 'ontological'.


-- ── A8. Statement counts by statement_kind ────────────────────

SELECT
    statement_kind,
    count(*)                                   AS n_statements,
    round(avg(seb.effective_mean)::numeric, 4) AS avg_effective_belief
FROM statements s
JOIN statement_effective_belief seb ON seb.id = s.id
GROUP BY statement_kind
ORDER BY statement_kind;
-- Expect: ontological (majority), statistical (typicality), rule (FOL rules).
-- effective_mean is NULL for rule statements (excluded from belief pipeline).


-- ── A9. Sentinel objects ──────────────────────────────────────
-- Sentinels are inference-opaque: is_sentinel=true, no type_membership
-- entries, cannot appear in structural predicates (trg_d enforces).

SELECT
    canonical_name,
    display_name,
    is_sentinel,
    description
FROM objects
WHERE is_sentinel = true
ORDER BY canonical_name;
-- Expect: false, no_period, no_scope, true, unknown.


-- ════════════════════════════════════════════════════════════
-- PART B: SIMPLE QUERIES ON KERNEL CONTENT
-- ════════════════════════════════════════════════════════════

-- ── B1. Boolean: "Is a mammal an animal?" ────────────────────

SELECT
    child.canonical_name                       AS subtype,
    parent.canonical_name                      AS supertype,
    round(seb.effective_mean::numeric, 4)      AS effective_belief,
    round(seb.raw_mean::numeric, 4)            AS raw_belief,
    s.t_kind
FROM statements s
JOIN statement_effective_belief seb ON seb.id     = s.id
JOIN objects child                  ON child.id   = s.object_args[1]
JOIN objects parent                 ON parent.id  = s.object_args[2]
WHERE s.predicate_id        = stable_uuid('subtype_of', 'predicate')
  AND child.canonical_name  = 'mammal'
  AND parent.canonical_name = 'animal';
-- Expect: effective_belief ≈ 1.0000, t_kind = 'eternal'


-- ── B2. Binding: "What is person a subtype of?" ──────────────

SELECT
    parent.canonical_name                      AS is_subtype_of,
    round(seb.effective_mean::numeric, 4)      AS belief,
    s.t_kind
FROM statements s
JOIN statement_effective_belief seb ON seb.id     = s.id
JOIN objects child                  ON child.id   = s.object_args[1]
JOIN objects parent                 ON parent.id  = s.object_args[2]
WHERE s.predicate_id       = stable_uuid('subtype_of', 'predicate')
  AND child.canonical_name = 'person'
ORDER BY seb.effective_mean DESC;
-- Expect: mammal, agent (both near-certain, eternal)


-- ── B3. Reverse binding: "What are direct subtypes of entity?" ─

SELECT
    child.canonical_name                       AS subtype,
    round(seb.effective_mean::numeric, 4)      AS belief
FROM statements s
JOIN statement_effective_belief seb ON seb.id     = s.id
JOIN objects child                  ON child.id   = s.object_args[1]
JOIN objects parent                 ON parent.id  = s.object_args[2]
WHERE s.predicate_id        = stable_uuid('subtype_of', 'predicate')
  AND parent.canonical_name = 'entity'
ORDER BY seb.effective_mean DESC;


-- ── B4. Typicality: all typical_of statements ranked ─────────
-- All typicality statements have statement_kind = 'statistical' (enforced
-- by trg_b). They are excluded from logical inference chains but visible
-- here. effective_mean = raw_mean for statistical statements (no competition
-- model applied).

SELECT
    instance.canonical_name                    AS instance,
    type_obj.canonical_name                    AS typical_of,
    round(seb.effective_mean::numeric, 4)      AS typicality,
    s.statement_kind
FROM statements s
JOIN statement_effective_belief seb ON seb.id      = s.id
JOIN objects instance               ON instance.id = s.object_args[1]
JOIN objects type_obj               ON type_obj.id = s.object_args[2]
WHERE s.predicate_id  = stable_uuid('typical_of', 'predicate')
ORDER BY seb.effective_mean DESC;
-- Expect: person→agent highest (~0.90); all statement_kind = 'statistical'.


-- ── B5. Check a constraint disjointness ──────────────────────
-- disjointness_kind = 'constraint' → trg_za blocks any is_a that
-- violates it. belief ≈ 1.0.

SELECT
    a.canonical_name                           AS type_a,
    b.canonical_name                           AS type_b,
    s.disjointness_kind,
    round(seb.effective_mean::numeric, 4)      AS belief,
    s.t_kind
FROM statements s
JOIN statement_effective_belief seb ON seb.id = s.id
JOIN objects a                      ON a.id   = s.object_args[1]
JOIN objects b                      ON b.id   = s.object_args[2]
WHERE s.predicate_id     = stable_uuid('disjoint_with', 'predicate')
  AND a.canonical_name   = 'number'
  AND b.canonical_name   = 'organism';
-- Expect: disjointness_kind = 'constraint', belief ≈ 1.0000


-- ── B6. Check an incompatibility disjointness ────────────────
-- disjointness_kind = 'incompatibility' → no hard block; scales the
-- competition-model denominator in statement_effective_belief.
-- belief 0.7–0.9 reflects acknowledged edge cases.

SELECT
    a.canonical_name                           AS type_a,
    b.canonical_name                           AS type_b,
    s.disjointness_kind,
    round(seb.effective_mean::numeric, 4)      AS belief,
    round(seb.raw_mean::numeric, 4)            AS raw_mean
FROM statements s
JOIN statement_effective_belief seb ON seb.id = s.id
JOIN objects a                      ON a.id   = s.object_args[1]
JOIN objects b                      ON b.id   = s.object_args[2]
WHERE s.predicate_id     = stable_uuid('disjoint_with', 'predicate')
  AND a.canonical_name   = 'person'
  AND b.canonical_name   = 'institution';
-- Expect: disjointness_kind = 'incompatibility', belief ≈ 0.90
-- (sole-trader legal edge case; trg_za does NOT block is_a(X, person)
-- when X is already typed as institution)


-- ════════════════════════════════════════════════════════════
-- PART C: INSERTING INDIVIDUALS AND ASSERTING FACTS
-- ════════════════════════════════════════════════════════════
-- Named individuals use kind = 'entity' and stable_uuid(name,'entity').
-- Type information lives in is_a statements, which fire
-- trg_sync_type_membership and populate type_membership automatically.
-- Do NOT insert into type_membership directly.
--
-- mathematician, programmer, inventor are seeded in common_objects_kernel.sql
-- as subtypes of role. Do not re-insert them here. Reference them via
-- stable_uuid(name,'entity') directly.

-- ── C1. Insert named individuals ─────────────────────────────

INSERT INTO objects (id, kind, canonical_name, display_name, aliases, external_ids)
VALUES (
    stable_uuid('ada_lovelace', 'entity'),
    'entity', 'ada_lovelace', 'Ada Lovelace',
    ARRAY['Augusta Ada King', 'Countess of Lovelace', 'Ada Byron'],
    '{"wikidata":"Q7259"}'::jsonb
) ON CONFLICT (canonical_name, kind) DO NOTHING;

INSERT INTO objects (id, kind, canonical_name, display_name, aliases, external_ids)
VALUES (
    stable_uuid('charles_babbage', 'entity'),
    'entity', 'charles_babbage', 'Charles Babbage',
    ARRAY['Babbage'],
    '{"wikidata":"Q46884"}'::jsonb
) ON CONFLICT (canonical_name, kind) DO NOTHING;

INSERT INTO objects (id, kind, canonical_name, display_name, description, external_ids)
VALUES (
    stable_uuid('difference_engine', 'entity'),
    'entity', 'difference_engine', 'Difference Engine',
    'Mechanical general-purpose computer designed by Charles Babbage.',
    '{"wikidata":"Q181348"}'::jsonb
) ON CONFLICT (canonical_name, kind) DO NOTHING;

INSERT INTO objects (id, kind, canonical_name, display_name, external_ids)
VALUES (
    stable_uuid('university_of_cambridge', 'entity'),
    'entity', 'university_of_cambridge', 'University of Cambridge',
    '{"wikidata":"Q35794"}'::jsonb
) ON CONFLICT (canonical_name, kind) DO NOTHING;

INSERT INTO objects (id, kind, canonical_name, display_name, external_ids)
VALUES (
    stable_uuid('london', 'entity'),
    'entity', 'london', 'London',
    '{"wikidata":"Q84"}'::jsonb
) ON CONFLICT (canonical_name, kind) DO NOTHING;


-- ── C2. Assert types via is_a statements ─────────────────────
-- is_a statements are the canonical type mechanism.
-- trg_sync_type_membership fires automatically and populates
-- type_membership. Do NOT insert into type_membership directly.
-- statement_kind = 'empirical' for individual classifications.
-- Note: trg_c_enforce_is_a_target rejects any target in the role
-- hierarchy — use has_role for roles, not is_a.

-- ada_lovelace is_a person
INSERT INTO statements (
    predicate_id, object_args,
    belief_alpha, belief_beta,
    statement_kind, t_kind, context_id, derivation_type
) VALUES (
    stable_uuid('is_a',    'predicate'),
    ARRAY[
        stable_uuid('ada_lovelace', 'entity'),
        stable_uuid('person',       'entity')
    ],
    1000.0, 0.001,
    'empirical', 'eternal',
    stable_uuid('reality', 'context'),
    'user_asserted'
) ON CONFLICT DO NOTHING;

-- charles_babbage is_a person
INSERT INTO statements (
    predicate_id, object_args,
    belief_alpha, belief_beta,
    statement_kind, t_kind, context_id, derivation_type
) VALUES (
    stable_uuid('is_a',    'predicate'),
    ARRAY[
        stable_uuid('charles_babbage', 'entity'),
        stable_uuid('person',          'entity')
    ],
    1000.0, 0.001,
    'empirical', 'eternal',
    stable_uuid('reality', 'context'),
    'user_asserted'
) ON CONFLICT DO NOTHING;

-- difference_engine is_a artifact
INSERT INTO statements (
    predicate_id, object_args,
    belief_alpha, belief_beta,
    statement_kind, t_kind, context_id, derivation_type
) VALUES (
    stable_uuid('is_a',     'predicate'),
    ARRAY[
        stable_uuid('difference_engine', 'entity'),
        stable_uuid('artifact',          'entity')
    ],
    1000.0, 0.001,
    'empirical', 'eternal',
    stable_uuid('reality', 'context'),
    'user_asserted'
) ON CONFLICT DO NOTHING;

-- university_of_cambridge is_a institution
INSERT INTO statements (
    predicate_id, object_args,
    belief_alpha, belief_beta,
    statement_kind, t_kind, context_id, derivation_type
) VALUES (
    stable_uuid('is_a',     'predicate'),
    ARRAY[
        stable_uuid('university_of_cambridge', 'entity'),
        stable_uuid('institution',             'entity')
    ],
    1000.0, 0.001,
    'empirical', 'eternal',
    stable_uuid('reality', 'context'),
    'user_asserted'
) ON CONFLICT DO NOTHING;

-- Attest the ada_lovelace is_a person statement.
WITH stmt AS (
    SELECT id FROM statements
    WHERE predicate_id = stable_uuid('is_a', 'predicate')
      AND object_args  = ARRAY[
            stable_uuid('ada_lovelace', 'entity'),
            stable_uuid('person',       'entity')]
)
INSERT INTO attestations (statement_id, source_id, url)
SELECT stmt.id,
       stable_uuid('wikidata', 'source'),
       'https://www.wikidata.org/wiki/Q7259'
FROM stmt
ON CONFLICT DO NOTHING;

-- Verify that type_membership was populated by the trigger.
SELECT
    obj.canonical_name  AS object,
    typ.canonical_name  AS type,
    round((tm.alpha / (tm.alpha + tm.beta))::numeric, 4) AS belief
FROM type_membership tm
JOIN objects obj ON obj.id = tm.object_id
JOIN objects typ ON typ.id = tm.type_id
WHERE obj.canonical_name IN (
    'ada_lovelace','charles_babbage','difference_engine','university_of_cambridge'
)
ORDER BY obj.canonical_name, typ.canonical_name;
-- Expect: 4 rows populated by trg_sync_type_membership, not manually.


-- ── C3. Assert: Ada Lovelace held role "mathematician" ────────
-- has_role(entity, role, scope) — ternary.
-- no_scope: the role genuinely has no institutional scope.
-- Ada worked independently — structurally different from "scope unknown".

INSERT INTO statements (
    predicate_id, object_args,
    belief_alpha, belief_beta,
    statement_kind, t_kind, context_id, derivation_type
) VALUES (
    stable_uuid('has_role', 'predicate'),
    ARRAY[
        stable_uuid('ada_lovelace',  'entity'),
        stable_uuid('mathematician', 'entity'),
        stable_uuid('no_scope',      'entity')   -- genuinely unscoped, not unknown
    ],
    13.0, 2.0,
    'empirical', 'always',
    stable_uuid('reality', 'context'),
    'source_ingested'
);

WITH stmt AS (
    SELECT id FROM statements
    WHERE predicate_id   = stable_uuid('has_role', 'predicate')
      AND object_args[1] = stable_uuid('ada_lovelace',  'entity')
      AND object_args[2] = stable_uuid('mathematician', 'entity')
    ORDER BY created_at DESC LIMIT 1
)
INSERT INTO attestations (statement_id, source_id, url)
SELECT stmt.id,
       stable_uuid('wikidata', 'source'),
       'https://www.wikidata.org/wiki/Q7259'
FROM stmt;


-- ── C4. Assert: Lovelace held role "programmer" at Difference Engine ─
-- Temporal interval: approximately 1842–1843 (the Notes translation).
-- The scope is the difference_engine — a real semantic argument.
-- interval t_kind requires both t_start and t_end (CHECK enforced by schema).

INSERT INTO statements (
    predicate_id, object_args,
    belief_alpha, belief_beta,
    statement_kind, t_kind, t_start, t_end,
    context_id, derivation_type
) VALUES (
    stable_uuid('has_role', 'predicate'),
    ARRAY[
        stable_uuid('ada_lovelace',      'entity'),
        stable_uuid('programmer',        'entity'),
        stable_uuid('difference_engine', 'entity')
    ],
    13.0, 2.0,
    'empirical', 'interval',
    ROW(year_to_jd(1842), year_to_jd(1841), year_to_jd(1843), 'year')::fuzzy_time,
    ROW(year_to_jd(1843), year_to_jd(1842), year_to_jd(1845), 'year')::fuzzy_time,
    stable_uuid('reality', 'context'),
    'source_ingested'
);


-- ── C5. Assert: Babbage created the Difference Engine ─────────

INSERT INTO statements (
    predicate_id, object_args,
    belief_alpha, belief_beta,
    statement_kind, t_kind, context_id, derivation_type
) VALUES (
    stable_uuid('created_by', 'predicate'),
    ARRAY[
        stable_uuid('difference_engine', 'entity'),
        stable_uuid('charles_babbage',   'entity')
    ],
    13.0, 2.0,
    'empirical', 'always',
    stable_uuid('reality', 'context'),
    'source_ingested'
);


-- ── C6. Assert: Babbage affiliated with Cambridge ─────────────
-- Babbage was Lucasian Professor of Mathematics 1828–1839.
-- Temporal scope in t_start/t_end; capacity arg is the named role.

INSERT INTO objects (id, kind, canonical_name, display_name, description)
VALUES (
    stable_uuid('lucasian_professor', 'entity'),
    'entity', 'lucasian_professor', 'Lucasian Professor of Mathematics',
    'The Lucasian Chair of Mathematics at the University of Cambridge.'
) ON CONFLICT (canonical_name, kind) DO NOTHING;

INSERT INTO statements (
    predicate_id, object_args,
    belief_alpha, belief_beta,
    statement_kind, t_kind, t_start, t_end,
    context_id, derivation_type
) VALUES (
    stable_uuid('affiliated_with', 'predicate'),
    ARRAY[
        stable_uuid('charles_babbage',         'entity'),
        stable_uuid('university_of_cambridge', 'entity'),
        stable_uuid('lucasian_professor',      'entity')
    ],
    13.0, 2.0,
    'empirical', 'interval',
    ROW(year_to_jd(1828), year_to_jd(1827), year_to_jd(1829), 'year')::fuzzy_time,
    ROW(year_to_jd(1839), year_to_jd(1838), year_to_jd(1840), 'year')::fuzzy_time,
    stable_uuid('reality', 'context'),
    'source_ingested'
);


-- ── C7. Assert: Lovelace was born in London (circa 1815) ──────
-- CORRECT TEMPORAL PATTERN for located_in:
-- • Third arg is no_period (not no_scope) because no named time period
--   is the semantic argument — the temporal scope belongs in t_start/t_end.
-- • t_kind = 'point' requires t_start non-null and t_end null (CHECK).
-- • point statements use granularity-aware overlap in holds_at():
--   year granularity → covers the entire calendar year [1815, 1816).
-- • no_scope is restricted to role-scope args (has_role third arg).
-- • A bare year-object or no_scope would be wrong in this position.

INSERT INTO statements (
    predicate_id, object_args,
    belief_alpha, belief_beta,
    statement_kind, t_kind, t_start,
    context_id, derivation_type
) VALUES (
    stable_uuid('located_in', 'predicate'),
    ARRAY[
        stable_uuid('ada_lovelace', 'entity'),
        stable_uuid('london',       'entity'),
        stable_uuid('no_period',    'entity')   -- no named period is the semantic arg
    ],
    13.0, 2.0,
    'empirical', 'point',
    -- t_start encodes birth ≈ 1815, ±1 year fuzzy bound
    ROW(year_to_jd(1815), year_to_jd(1815), year_to_jd(1816), 'year')::fuzzy_time,
    stable_uuid('reality', 'context'),
    'source_ingested'
);


-- ── C8. Assert a has_value fact ───────────────────────────────
-- has_value(entity, attribute, value) — third arg is a literal.
-- "The Difference Engine has approximately 25,000 parts."

INSERT INTO objects (id, kind, canonical_name, display_name, description)
VALUES (
    stable_uuid('component_count', 'entity'),
    'entity', 'component_count', 'Component count',
    'The number of distinct components in a mechanical or electronic system.'
) ON CONFLICT (canonical_name, kind) DO NOTHING;

INSERT INTO statements (
    predicate_id, object_args, literal_args,
    belief_alpha, belief_beta,
    statement_kind, t_kind, context_id, derivation_type
) VALUES (
    stable_uuid('has_value', 'predicate'),
    ARRAY[
        stable_uuid('difference_engine', 'entity'),
        stable_uuid('component_count',   'entity')
    ],
    '[{"pos":2,"type":"integer","value":25000}]'::jsonb,
    8.0, 2.0,
    'empirical', 'always',
    stable_uuid('reality', 'context'),
    'source_ingested'
);


-- ── C9. Inverse predicate automation ─────────────────────────
-- part_of ↔ has_part wiring seeded in common_predicates_kernel.sql.
-- trg_zz_auto_inverse_statement fires on INSERT and UPDATE:
--   INSERT path  → creates has_part(B, A) as forward_chained.
--   UPDATE path  → propagates belief changes to the existing inverse.

INSERT INTO objects (id, kind, canonical_name, display_name, description)
VALUES (
    stable_uuid('babbage_workshop', 'entity'),
    'entity', 'babbage_workshop', 'Babbage''s Workshop',
    'The mechanical workshop where Babbage constructed the Difference Engine.'
) ON CONFLICT (canonical_name, kind) DO NOTHING;

-- Insert the forward direction; inverse is auto-created.
-- t_kind = 'always': no specific dates known for this mereological relationship.
-- (interval would require both t_start and t_end per schema CHECK constraint.)
INSERT INTO statements (
    predicate_id, object_args,
    belief_alpha, belief_beta,
    statement_kind, t_kind, context_id, derivation_type
) VALUES (
    stable_uuid('part_of', 'predicate'),
    ARRAY[
        stable_uuid('difference_engine', 'entity'),
        stable_uuid('babbage_workshop',  'entity')
    ],
    9.0, 3.0,
    'empirical', 'always',
    stable_uuid('reality', 'context'),
    'user_asserted'
);

-- Verify the trigger created the inverse automatically.
SELECT
    p.canonical_name                               AS predicate,
    a.canonical_name                               AS arg1,
    b.canonical_name                               AS arg2,
    s.derivation_type,
    s.statement_kind,
    round(s.belief_mean::numeric, 4)               AS belief
FROM statements s
JOIN objects p ON p.id = s.predicate_id
JOIN objects a ON a.id = s.object_args[1]
JOIN objects b ON b.id = s.object_args[2]
WHERE s.predicate_id IN (
    stable_uuid('part_of',  'predicate'),
    stable_uuid('has_part', 'predicate')
)
  AND (s.object_args[1] = stable_uuid('difference_engine', 'entity')
    OR s.object_args[2] = stable_uuid('difference_engine', 'entity'))
ORDER BY p.canonical_name;
-- Expect: part_of(difference_engine, babbage_workshop) derivation_type='user_asserted'
--         has_part(babbage_workshop, difference_engine) derivation_type='forward_chained'
-- Both rows share the same belief_mean.

-- Demonstrate the UPDATE path: updating belief on the source propagates
-- to the existing inverse statement via the trigger's UPDATE branch.
UPDATE statements
   SET belief_alpha = 12.0,
       belief_beta  = 2.0
WHERE predicate_id  = stable_uuid('part_of', 'predicate')
  AND object_args   = ARRAY[
        stable_uuid('difference_engine', 'entity'),
        stable_uuid('babbage_workshop',  'entity')
      ];

-- Verify the inverse also updated.
SELECT
    p.canonical_name                   AS predicate,
    a.canonical_name                   AS arg1,
    b.canonical_name                   AS arg2,
    round(s.belief_mean::numeric, 4)   AS belief
FROM statements s
JOIN objects p ON p.id = s.predicate_id
JOIN objects a ON a.id = s.object_args[1]
JOIN objects b ON b.id = s.object_args[2]
WHERE s.predicate_id IN (
    stable_uuid('part_of',  'predicate'),
    stable_uuid('has_part', 'predicate')
)
  AND (s.object_args[1] = stable_uuid('difference_engine', 'entity')
    OR s.object_args[2] = stable_uuid('difference_engine', 'entity'))
ORDER BY p.canonical_name;
-- Expect: both rows now show belief_mean ≈ 0.857 (12/(12+2)).


-- ════════════════════════════════════════════════════════════
-- PART D: TEMPORAL QUERIES
-- holds_at() takes p_threshold and p_min_evidence explicitly.
-- In open_world mode, holds_at() filters on effective_mean from
-- statement_effective_belief (credibility-adjusted, competition-normalised),
-- not raw belief_mean.
-- point statements use granularity-aware overlap via
-- point_statement_contains() rather than coalescing t_end to infinity.
-- ════════════════════════════════════════════════════════════

-- ── D1. "Was Lovelace a programmer in 1843?" ─────────────────

SELECT *
FROM holds_at(
    stable_uuid('has_role',    'predicate'),
    ARRAY[
        stable_uuid('ada_lovelace',      'entity'),
        stable_uuid('programmer',        'entity'),
        stable_uuid('difference_engine', 'entity')
    ],
    '1843-01-01 00:00:00+00'::timestamptz,
    stable_uuid('reality', 'context'),
    'open_world',
    0.5,   -- p_threshold (applied to effective_mean)
    0.0    -- p_min_evidence (default)
);
-- Expect: one row, belief ≈ 0.867


-- ── D2. "Was Lovelace a programmer in 1800?" ─────────────────

SELECT *
FROM holds_at(
    stable_uuid('has_role',    'predicate'),
    ARRAY[
        stable_uuid('ada_lovelace',      'entity'),
        stable_uuid('programmer',        'entity'),
        stable_uuid('difference_engine', 'entity')
    ],
    '1800-01-01 00:00:00+00'::timestamptz,
    stable_uuid('reality', 'context'),
    'open_world',
    0.5,
    0.0
);
-- Expect: empty (before she was born)


-- ── D3. "Was Babbage at Cambridge in 1835?" ──────────────────

SELECT *
FROM holds_at(
    stable_uuid('affiliated_with', 'predicate'),
    ARRAY[
        stable_uuid('charles_babbage',         'entity'),
        stable_uuid('university_of_cambridge', 'entity'),
        stable_uuid('lucasian_professor',      'entity')
    ],
    '1835-06-01 00:00:00+00'::timestamptz,
    stable_uuid('reality', 'context'),
    'open_world',
    0.5,
    0.0
);
-- Expect: one row, belief ≈ 0.867


-- ── D4. "Was Babbage at Cambridge in 1850?" ──────────────────

SELECT *
FROM holds_at(
    stable_uuid('affiliated_with', 'predicate'),
    ARRAY[
        stable_uuid('charles_babbage',         'entity'),
        stable_uuid('university_of_cambridge', 'entity'),
        stable_uuid('lucasian_professor',      'entity')
    ],
    '1850-01-01 00:00:00+00'::timestamptz,
    stable_uuid('reality', 'context'),
    'open_world',
    0.5,
    0.0
);
-- Expect: empty (chair ended 1839)


-- ── D5. "Is person always a subtype of mammal?" ──────────────

SELECT *
FROM holds_at(
    stable_uuid('subtype_of', 'predicate'),
    ARRAY[
        stable_uuid('person', 'entity'),
        stable_uuid('mammal', 'entity')
    ],
    now(),
    stable_uuid('reality', 'context'),
    'open_world',
    0.5,
    0.0
);
-- Expect: one row, belief ≈ 1.0000, t_kind = 'eternal'


-- ── D6. Evidence-weighted mode ────────────────────────────────
-- Returns all matching statements regardless of effective_mean,
-- ordered by effective_mean DESC. For the reasoning layer.

SELECT *
FROM holds_at(
    stable_uuid('has_role', 'predicate'),
    ARRAY[
        stable_uuid('ada_lovelace',  'entity'),
        stable_uuid('mathematician', 'entity'),
        stable_uuid('no_scope',      'entity')
    ],
    now(),
    stable_uuid('reality', 'context'),
    'evidence_weighted',
    0.5,
    0.0
);


-- ── D7. Low-threshold query ───────────────────────────────────
-- p_threshold = 0.4 captures borderline facts.
-- p_min_evidence > 2.0 requires more than the uniform prior.
-- Together: "effective belief > 0.4 backed by real evidence."

SELECT *
FROM holds_at(
    stable_uuid('has_role', 'predicate'),
    ARRAY[
        stable_uuid('ada_lovelace',  'entity'),
        stable_uuid('mathematician', 'entity'),
        stable_uuid('no_scope',      'entity')
    ],
    now(),
    stable_uuid('reality', 'context'),
    'open_world',
    0.4,    -- p_threshold: lower than default
    4.0     -- p_min_evidence: require at least 4 evidence units
);


-- ── D8. Point statement granularity-aware overlap ────────────
-- A year-granularity point at 1815 overlaps any query within
-- [1815-01-01, 1816-01-01). This is the granularity-aware behaviour
-- of point_statement_contains() — the fuzzy_time lo/hi bounds define
-- the window, so "born in 1815" correctly matches queries in 1815.

-- This should match: query time is within the 1815 year window.
SELECT 'mid-1815 matches birth' AS test,
       count(*) > 0              AS matched
FROM holds_at(
    stable_uuid('located_in', 'predicate'),
    ARRAY[
        stable_uuid('ada_lovelace', 'entity'),
        stable_uuid('london',       'entity'),
        stable_uuid('no_period',    'entity')
    ],
    '1815-07-01 00:00:00+00'::timestamptz,
    stable_uuid('reality', 'context'),
    'open_world', 0.5, 0.0
);
-- Expect: matched = true

-- This should NOT match: 1817 is outside the year-1815 fuzzy window.
SELECT '1817 does not match birth' AS test,
       count(*) = 0                AS not_matched
FROM holds_at(
    stable_uuid('located_in', 'predicate'),
    ARRAY[
        stable_uuid('ada_lovelace', 'entity'),
        stable_uuid('london',       'entity'),
        stable_uuid('no_period',    'entity')
    ],
    '1817-01-01 00:00:00+00'::timestamptz,
    stable_uuid('reality', 'context'),
    'open_world', 0.5, 0.0
);
-- Expect: not_matched = true


-- ════════════════════════════════════════════════════════════
-- PART E: BAYESIAN BELIEF AND TRUST UPDATES
-- ════════════════════════════════════════════════════════════

-- ── E1. Add a second source and update belief ─────────────────

INSERT INTO objects (id, kind, canonical_name, display_name, description)
VALUES (
    stable_uuid('lovelace_biography', 'source'),
    'source', 'lovelace_biography', 'Ada Lovelace: The Making of a Computer Scientist',
    'Scholarly biography by Hollings, Martin & Rice (2018).'
) ON CONFLICT (canonical_name, kind) DO NOTHING;

INSERT INTO source_credibility (source_id, context_id, alpha, beta)
VALUES (
    stable_uuid('lovelace_biography', 'source'),
    stable_uuid('domain_history',     'context'),
    18.0, 2.0
) ON CONFLICT DO NOTHING;

INSERT INTO source_credibility (source_id, context_id, alpha, beta)
VALUES (
    stable_uuid('lovelace_biography', 'source'),
    stable_uuid('domain_technology',  'context'),
    9.0, 3.0
) ON CONFLICT DO NOTHING;

WITH stmt AS (
    SELECT id FROM statements
    WHERE predicate_id   = stable_uuid('has_role', 'predicate')
      AND object_args[1] = stable_uuid('ada_lovelace',  'entity')
      AND object_args[2] = stable_uuid('mathematician', 'entity')
    ORDER BY created_at DESC LIMIT 1
)
INSERT INTO attestations (statement_id, source_id, confidence_weight, url)
SELECT
    stmt.id,
    stable_uuid('lovelace_biography', 'source'),
    1.0,
    'https://www.bodleian.ox.ac.uk/whats-on/events/2018/october/ada-lovelace-book-launch'
FROM stmt;

-- Check effective belief before update.
-- [v0.9 / Fix 12] For empirical statements with no conflicts,
-- effective_mean = posterior_mean: the statement's own Beta plus the
-- source-credibility-weighted pseudo-counts of its (deduped)
-- attestations. credibility_adjusted is now a diagnostic only (mean
-- source credibility; NULL when unattested).
SELECT
    round(seb.raw_mean::numeric, 4)            AS raw_belief_before,
    round(seb.posterior_mean::numeric, 4)      AS posterior_before,
    round(seb.credibility_adjusted::numeric, 4) AS credibility_diag,
    round(seb.effective_mean::numeric, 4)      AS effective_belief_before,
    seb.open_conflict_count,
    s.belief_alpha + s.belief_beta             AS evidence_strength
FROM statements s
JOIN statement_effective_belief seb ON seb.id = s.id
WHERE s.predicate_id   = stable_uuid('has_role', 'predicate')
  AND s.object_args[1] = stable_uuid('ada_lovelace',  'entity')
  AND s.object_args[2] = stable_uuid('mathematician', 'entity')
ORDER BY s.created_at DESC LIMIT 1;

-- update_belief requires p_override=false (default) for empirical statements.
-- For ontological statements, p_override=true is required; otherwise an
-- exception is raised (fixed belief for structural axioms).
SELECT update_belief(
    (SELECT id FROM statements
     WHERE predicate_id   = stable_uuid('has_role', 'predicate')
       AND object_args[1] = stable_uuid('ada_lovelace',  'entity')
       AND object_args[2] = stable_uuid('mathematician', 'entity')
     ORDER BY created_at DESC LIMIT 1),
    0.90,   -- weight
    true,   -- p_supports
    false   -- p_override (not needed for empirical)
);

-- Check effective belief after update.
-- [v0.9 / Fix 12] effective_mean MOVES with update_belief now. In v0.8
-- the attestation-derived credibility silently masked the statement's
-- own Beta, so this update changed raw_mean but left effective_mean
-- frozen.
SELECT
    round(seb.raw_mean::numeric, 4)            AS raw_belief_after,
    round(seb.posterior_mean::numeric, 4)      AS posterior_after,
    round(seb.effective_mean::numeric, 4)      AS effective_belief_after,
    round(seb.conflict_severity::numeric, 4)   AS conflict_severity,
    s.belief_alpha + s.belief_beta             AS evidence_strength
FROM statements s
JOIN statement_effective_belief seb ON seb.id = s.id
WHERE s.predicate_id   = stable_uuid('has_role', 'predicate')
  AND s.object_args[1] = stable_uuid('ada_lovelace',  'entity')
  AND s.object_args[2] = stable_uuid('mathematician', 'entity')
ORDER BY s.created_at DESC LIMIT 1;
-- raw mean rises ~0.867 → ~0.874 and, unlike v0.8, the posterior and
-- effective belief rise with it.


-- ── E2. Evidence grouping — correlated sources ───────────────
-- statement_credibility enforces: each evidence_group_id contributes
-- at most its single highest-weight attestation to the credibility sum.
-- Britannica and Wikidata are grouped (both derived from the same
-- primary sources). Only the higher-weight attestation counts.

INSERT INTO objects (id, kind, canonical_name, display_name)
VALUES (
    stable_uuid('encyclopedia_britannica_online', 'source'),
    'source', 'encyclopedia_britannica_online', 'Encyclopædia Britannica Online'
) ON CONFLICT (canonical_name, kind) DO NOTHING;

INSERT INTO source_credibility (source_id, context_id, alpha, beta)
VALUES (
    stable_uuid('encyclopedia_britannica_online', 'source'),
    stable_uuid('domain_history', 'context'),
    15.0, 2.0
) ON CONFLICT DO NOTHING;

DO $$
DECLARE
    group_id uuid := stable_uuid('wikidata_derived_sources', 'source');
    stmt_id  uuid;
BEGIN
    SELECT id INTO stmt_id
    FROM statements
    WHERE predicate_id   = stable_uuid('has_role', 'predicate')
      AND object_args[1] = stable_uuid('ada_lovelace',  'entity')
      AND object_args[2] = stable_uuid('mathematician', 'entity')
    ORDER BY created_at DESC LIMIT 1;

    INSERT INTO attestations
        (statement_id, source_id, evidence_group_id, confidence_weight)
    VALUES (
        stmt_id,
        stable_uuid('encyclopedia_britannica_online', 'source'),
        group_id,
        0.7
    );

    UPDATE attestations
    SET evidence_group_id = group_id
    WHERE statement_id = stmt_id
      AND source_id    = stable_uuid('wikidata', 'source');

    RAISE NOTICE 'Evidence group % assigned. '
                 'Highest weight in group will dominate credibility sum.', group_id;
END $$;

-- Verify the group aggregation rule in statement_credibility.
SELECT
    sc.statement_id,
    round(sc.weighted_credibility::numeric, 4)  AS weighted_credibility,
    round(sc.total_source_weight::numeric, 2)   AS total_weight,
    sc.source_count
FROM statement_credibility sc
JOIN statements s ON s.id = sc.statement_id
WHERE s.predicate_id   = stable_uuid('has_role', 'predicate')
  AND s.object_args[1] = stable_uuid('ada_lovelace',  'entity')
  AND s.object_args[2] = stable_uuid('mathematician', 'entity');
-- Expect: total_weight reflects only the highest-weight attestation per
-- group — no inflation from Britannica and Wikidata both counting.


-- ── E3. Trust penalty: a source gets something wrong ─────────

SELECT update_trust(
    stable_uuid('llm_generated', 'source'),
    stable_uuid('domain_history', 'context'),
    false,   -- incorrect
    1.0,
    false    -- p_override: not protected
);

SELECT
    o.canonical_name                          AS source,
    c.canonical_name                          AS context,
    round(scs.mean::numeric, 4)               AS credibility_mean,
    round(scs.ci_low::numeric, 4)             AS ci_low,
    round(scs.ci_high::numeric, 4)            AS ci_high,
    round(scs.evidence_strength::numeric, 1)  AS evidence_strength
FROM source_credibility_score scs
JOIN objects o ON o.id = scs.source_id
JOIN objects c ON c.id = scs.context_id
WHERE o.canonical_name = 'llm_generated'
ORDER BY c.canonical_name;


-- ── E4. Trust reward: wikidata confirmed correct ──────────────

SELECT update_trust(
    stable_uuid('wikidata',       'source'),
    stable_uuid('domain_science', 'context'),
    true,    -- correct
    1.5,
    false
);


-- ════════════════════════════════════════════════════════════
-- PART F: DERIVED STATEMENTS AND PROVENANCE
-- ════════════════════════════════════════════════════════════

-- ── F1. Forward-chain: "Lovelace is a mammal" ────────────────
-- Chain: lovelace is_a person ∧ person subtype_of mammal
--        → lovelace is_a mammal
-- Uses compute_derived_belief() for belief propagation.
-- [Fix 14] 'min' mode: result_mean = min(parent_means), then decayed
-- toward the 0.5 prior in log-odds space by 0.9^chain_length, and the
-- weakest parent's evidence strength is propagated (decayed, clamped to
-- [2, 1000]) instead of being reset to 2. Both parents here are
-- near-certain (~0.999 at strength ~1000), so the conclusion stays
-- near-certain at high strength — a conclusion of strong axioms no
-- longer carries the confidence interval of a twice-flipped coin.
-- Derived is_a statement uses statement_kind = 'empirical'.

DO $$
DECLARE
    ada_id     uuid := stable_uuid('ada_lovelace', 'entity');
    mammal_id  uuid := stable_uuid('mammal',       'entity');
    person_id  uuid := stable_uuid('person',       'entity');
    is_a_id    uuid := stable_uuid('is_a',         'predicate');
    subtype_id uuid := stable_uuid('subtype_of',   'predicate');
    reality_id uuid := stable_uuid('reality',      'context');
    src_stmt_1 uuid;
    src_stmt_2 uuid;
    new_stmt   uuid;
    d_alpha    double precision;
    d_beta     double precision;
BEGIN
    SELECT id INTO src_stmt_1
    FROM statements
    WHERE predicate_id = is_a_id
      AND object_args  = ARRAY[ada_id, person_id]
    LIMIT 1;

    SELECT id INTO src_stmt_2
    FROM statements
    WHERE predicate_id = subtype_id
      AND object_args  = ARRAY[person_id, mammal_id]
    LIMIT 1;

    IF src_stmt_1 IS NULL OR src_stmt_2 IS NULL THEN
        RAISE NOTICE 'Source statements not found; skipping derivation.';
        RETURN;
    END IF;

    -- Compute derived belief from parents.
    -- Note: compute_derived_belief raises a hard exception if any parent
    -- has statement_kind = 'statistical'. Only empirical and ontological
    -- parents are valid for logical inference chains.
    SELECT out_alpha, out_beta
    INTO d_alpha, d_beta
    FROM compute_derived_belief(
        ARRAY[src_stmt_1, src_stmt_2],
        1,       -- chain length (1 inference step)
        'min'    -- conservative combination
    );

    RAISE NOTICE 'compute_derived_belief → alpha=%, beta=% (mean≈%)',
        round(d_alpha::numeric,4),
        round(d_beta::numeric,4),
        round((d_alpha / (d_alpha + d_beta))::numeric,4);

    INSERT INTO statements (
        predicate_id, object_args,
        belief_alpha, belief_beta,
        statement_kind, t_kind, context_id,
        derivation_type, derivation_depth, derived_from,
        combination_mode          -- [Fix 23] replayed on recompute
    ) VALUES (
        is_a_id,
        ARRAY[ada_id, mammal_id],
        d_alpha, d_beta,
        'empirical', 'eternal', reality_id,
        'forward_chained', 1,
        ARRAY[src_stmt_1, src_stmt_2],
        'min'
    )
    RETURNING id INTO new_stmt;

    -- Authoritative provenance: statement_dependencies required for
    -- forward_chained statements (enforced by trg_enforce_provenance).
    INSERT INTO statement_dependencies (parent_id, child_id, rule_name, weight)
    VALUES
        (src_stmt_1, new_stmt, 'is_a + subtype_of → is_a', 1.0),
        (src_stmt_2, new_stmt, 'is_a + subtype_of → is_a', 1.0);

    RAISE NOTICE 'Derived statement created: % (lovelace is_a mammal, alpha=%)',
        new_stmt, round(d_alpha::numeric,4);
END $$;


-- ── F2. Premise conjunction vs evidence aggregation [Fix 14] ──
--
-- compute_derived_belief() combines the PREMISES of one rule
-- application. A conclusion can never be more believable than its
-- weakest premise (P(A ∧ B) ≤ min(P(A), P(B))), so the valid modes are:
--   'min'       — upper bound; exact for perfectly correlated premises.
--   'noisy_and' — product of means; exact for independent premises.
-- The v0.8 'log_odds' mode is REMOVED here: summing premise log-odds
-- claimed conclusions more certain than every premise. Calling it now
-- raises an instructive exception.
--
-- Log-odds accumulation lives on as combine_evidence(), whose semantics
-- it actually fits: merging multiple INDEPENDENT DERIVATIONS of the
-- SAME conclusion, where two independent 90% derivations correctly
-- combine to ≈ 0.988.
--
-- Note also (Fix 14): the output evidence strength is now propagated
-- from the weakest parent (decayed per chain step) instead of being
-- reset to 2.0, and chain-length decay shrinks belief toward the 0.5
-- prior in log-odds space instead of multiplying the probability
-- toward 0.

WITH parent_ids AS (
    SELECT ARRAY[
        (SELECT id FROM statements
         WHERE predicate_id = stable_uuid('is_a','predicate')
           AND object_args  = ARRAY[stable_uuid('ada_lovelace','entity'),
                                    stable_uuid('person','entity')]
         LIMIT 1),
        (SELECT id FROM statements
         WHERE predicate_id = stable_uuid('subtype_of','predicate')
           AND object_args  = ARRAY[stable_uuid('person','entity'),
                                    stable_uuid('mammal','entity')]
         LIMIT 1)
    ] AS ids
)
SELECT
    'min (premises, correlated)'      AS strategy,
    round(out_alpha::numeric,4) AS alpha,
    round(out_beta::numeric,4)  AS beta,
    round((out_alpha/(out_alpha+out_beta))::numeric,4) AS mean,
    round((out_alpha+out_beta)::numeric,2) AS strength
FROM parent_ids, compute_derived_belief(ids, 1, 'min')

UNION ALL

SELECT
    'noisy_and (premises, independent)',
    round(out_alpha::numeric,4),
    round(out_beta::numeric,4),
    round((out_alpha/(out_alpha+out_beta))::numeric,4),
    round((out_alpha+out_beta)::numeric,2)
FROM parent_ids, compute_derived_belief(ids, 1, 'noisy_and')

UNION ALL

-- Same parents fed to combine_evidence(), purely to show the numeric
-- contrast. (Semantically these two are premises, not independent
-- derivations of one conclusion — in real use combine_evidence() takes
-- the per-derivation results of compute_derived_belief().)
SELECT
    'combine_evidence (derivations)',
    round(out_alpha::numeric,4),
    round(out_beta::numeric,4),
    round((out_alpha/(out_alpha+out_beta))::numeric,4),
    round((out_alpha+out_beta)::numeric,2)
FROM parent_ids, combine_evidence(ids);
-- Premise modes stay at or below the weakest parent (then decay toward
-- 0.5); combine_evidence exceeds both — correct only for independent
-- derivations of the same conclusion.


-- ── F3. Provenance query: all statements about Lovelace ───────

SELECT
    sv.predicate                                  AS predicate,
    sv.arg_names                                  AS args,
    round(sv.belief_mean::numeric, 4)             AS belief,
    sv.statement_kind,
    sv.evidence_strength,
    sv.t_kind,
    sv.derivation_type,
    sv.derivation_depth,
    sv.derived_from
FROM statement_view sv
WHERE stable_uuid('ada_lovelace', 'entity') = ANY(sv.object_args)
ORDER BY sv.belief_mean DESC, sv.derivation_depth;


-- ── F4. Provenance: what sources attest a specific claim ──────

SELECT
    o_pred.canonical_name                                   AS predicate,
    round(sb.belief_mean::numeric, 4)                       AS belief_mean,
    s.t_kind,
    s.derivation_type,
    s.derivation_depth,
    array_agg(o_src.canonical_name ORDER BY a.created_at)  AS sources,
    array_agg(a.confidence_weight  ORDER BY a.created_at)  AS weights,
    array_agg(a.evidence_group_id  ORDER BY a.created_at)  AS evidence_groups
FROM statements s
JOIN statement_belief sb  ON sb.id     = s.id
JOIN objects o_pred       ON o_pred.id = s.predicate_id
LEFT JOIN attestations a  ON a.statement_id = s.id
LEFT JOIN objects o_src   ON o_src.id  = a.source_id
WHERE s.predicate_id   = stable_uuid('has_role', 'predicate')
  AND s.object_args[1] = stable_uuid('ada_lovelace',  'entity')
  AND s.object_args[2] = stable_uuid('mathematician', 'entity')
GROUP BY s.id, o_pred.canonical_name, sb.belief_mean,
         s.t_kind, s.derivation_type, s.derivation_depth;


-- ── F5. why() — full provenance graph ────────────────────────
-- Retrieves the recursive explanation tree for the derived
-- lovelace→mammal statement. Shows depth, rule applied at each
-- step, and both raw and effective belief at each node.

SELECT
    w.depth,
    w.predicate,
    w.arg_names,
    round(w.belief_mean::numeric, 4)    AS raw_belief,
    round(w.effective_mean::numeric, 4) AS effective_belief,
    w.rule_name,
    w.edge_weight,
    w.derivation_type,
    w.statement_kind
FROM why(
    (SELECT id FROM statements
     WHERE predicate_id  = stable_uuid('is_a', 'predicate')
       AND object_args   = ARRAY[
               stable_uuid('ada_lovelace', 'entity'),
               stable_uuid('mammal',       'entity')]
       AND derivation_type = 'forward_chained'
     LIMIT 1)
) w
ORDER BY w.depth, w.statement_id;
-- Expect:
--   depth 0: is_a(ada_lovelace, mammal)  — the conclusion
--   depth 1: is_a(ada_lovelace, person)  — parent via is_a+subtype_of rule
--   depth 1: subtype_of(person, mammal)  — parent via is_a+subtype_of rule


-- ── F6. Live derivation graph [Fix 23] ────────────────────────
-- The F1 conclusion (lovelace is_a mammal) was derived from
-- is_a(lovelace, person) ∧ subtype_of(person, mammal). In v0.9 it would
-- have kept its computed belief forever, however much the premises
-- later changed. Now: updating a premise's belief — or attesting it —
-- recomputes every forward_chained conclusion citing it, down the DAG.

-- Conclusion belief before touching the premise:
SELECT round(s.belief_mean::numeric, 4) AS conclusion_before,
       round((s.belief_alpha + s.belief_beta)::numeric, 1) AS strength_before
FROM statements s
WHERE s.predicate_id = stable_uuid('is_a','predicate')
  AND s.object_args  = ARRAY[stable_uuid('ada_lovelace','entity'),
                             stable_uuid('mammal','entity')]
  AND s.derivation_type = 'forward_chained';

-- Hit the weakest-link premise with substantial counter-evidence:
SELECT update_belief(
    (SELECT id FROM statements
     WHERE predicate_id = stable_uuid('is_a','predicate')
       AND object_args  = ARRAY[stable_uuid('ada_lovelace','entity'),
                                stable_uuid('person','entity')]),
    200.0,   -- weight
    false,   -- p_supports: AGAINST
    false
);

-- The conclusion followed automatically — no manual re-derivation:
SELECT round(s.belief_mean::numeric, 4) AS conclusion_after,
       round((s.belief_alpha + s.belief_beta)::numeric, 1) AS strength_after
FROM statements s
WHERE s.predicate_id = stable_uuid('is_a','predicate')
  AND s.object_args  = ARRAY[stable_uuid('ada_lovelace','entity'),
                             stable_uuid('mammal','entity')]
  AND s.derivation_type = 'forward_chained';
-- Expect: conclusion_before ≈ 1.0; after, the premise mean dropped to
-- ≈ 0.83, and the conclusion now sits just below it (min mode + one
-- step of log-odds decay) at reduced strength. The derivation graph is
-- live: what the premises lose, the conclusion loses.

-- Restore the premise (the conclusion follows back up):
SELECT update_belief(
    (SELECT id FROM statements
     WHERE predicate_id = stable_uuid('is_a','predicate')
       AND object_args  = ARRAY[stable_uuid('ada_lovelace','entity'),
                                stable_uuid('person','entity')]),
    200.0, true, false
);

-- Propagation also fires from the EVIDENCE side: attestations change a
-- premise's posterior without touching its statements row, and the
-- pipeline (Fix 23) is what derivations consume, so attaching one
-- recomputes the conclusion too.
INSERT INTO attestations (statement_id, source_id, confidence_weight)
VALUES (
    (SELECT id FROM statements
     WHERE predicate_id = stable_uuid('is_a','predicate')
       AND object_args  = ARRAY[stable_uuid('ada_lovelace','entity'),
                                stable_uuid('person','entity')]),
    stable_uuid('wikidata', 'source'),
    1.0
);

SELECT
    round(p_seb.raw_mean::numeric, 4)       AS premise_raw,
    round(p_seb.posterior_mean::numeric, 4) AS premise_posterior,
    round(c.belief_mean::numeric, 4)        AS conclusion_after_attestation
FROM statements c
JOIN statements p
  ON p.predicate_id = stable_uuid('is_a','predicate')
 AND p.object_args  = ARRAY[stable_uuid('ada_lovelace','entity'),
                            stable_uuid('person','entity')]
JOIN statement_effective_belief p_seb ON p_seb.id = p.id
WHERE c.predicate_id = stable_uuid('is_a','predicate')
  AND c.object_args  = ARRAY[stable_uuid('ada_lovelace','entity'),
                             stable_uuid('mammal','entity')]
  AND c.derivation_type = 'forward_chained';
-- Expect: the conclusion tracks the premise's POSTERIOR (raw +
-- attestation pseudo-counts), because the pipeline — not raw belief —
-- feeds derivations. Against a strength-~1000 premise, 5 attested
-- pseudo-observations move the posterior (and hence the conclusion)
-- only slightly; the point is the channel, not the magnitude. On a
-- weakly-believed premise the same attestation moves conclusions
-- substantially.

-- NOTE on ownership: forward_chained rows belong to the propagation
-- machinery — update_belief() directly on one is overwritten by the
-- next recompute. Direct evidence about a conclusion goes in
-- attestations ON the conclusion row; those fold into its posterior in
-- the view layer and survive recompute.

-- Changes that move effective_mean WITHOUT touching belief or
-- attestations (new conflicts, update_trust) do not auto-propagate;
-- validate_kb_integrity()'s stale_derived_belief check reports drift,
-- and recompute_derived_belief(id) repairs it on demand.


-- ── F7. Independence guard on combine_evidence [Fix 24] ───────
-- combine_evidence() sums log-odds, which is only valid for INDEPENDENT
-- derivations. The F1 conclusion and its own premise trivially share
-- provenance (one is the other's ancestor) — combining them would count
-- the premise's evidence twice. The guard catches it:

DO $$
DECLARE
    conclusion_id uuid;
    premise_id    uuid;
    a float; b float;
BEGIN
    SELECT id INTO conclusion_id FROM statements
    WHERE predicate_id = stable_uuid('is_a','predicate')
      AND object_args  = ARRAY[stable_uuid('ada_lovelace','entity'),
                               stable_uuid('mammal','entity')]
      AND derivation_type = 'forward_chained';

    SELECT id INTO premise_id FROM statements
    WHERE predicate_id = stable_uuid('is_a','predicate')
      AND object_args  = ARRAY[stable_uuid('ada_lovelace','entity'),
                               stable_uuid('person','entity')];

    BEGIN
        SELECT out_alpha, out_beta INTO a, b
        FROM combine_evidence(ARRAY[conclusion_id, premise_id]);
        RAISE NOTICE 'BUG: correlated parents were combined';
    EXCEPTION WHEN raise_exception THEN
        RAISE NOTICE 'CORRECT: combine_evidence refused correlated parents: %',
            left(SQLERRM, 80);
    END;

    -- Deliberate override remains available:
    SELECT out_alpha, out_beta INTO a, b
    FROM combine_evidence(ARRAY[conclusion_id, premise_id], false);
    RAISE NOTICE 'Override (p_check_independence => false) combined to mean ≈ %',
        round((a / (a + b))::numeric, 4);
END $$;


-- ════════════════════════════════════════════════════════════
-- PART G: CONFLICT DETECTION AND RESOLUTION
-- Evidential opposition is expressed as two competing positive
-- statements linked by a conflicts row. The "opposing" statement
-- has low alpha and high beta (low belief_mean).
-- detect_conflicts() populates severity and runs two passes:
--   1. direct_negation — same predicate+args, disjoint 95% CIs,
--      overlapping temporal scope;
--   2. value_conflict [Fix 17] — functional predicates: same leading
--      args, DIFFERENT value, overlapping time, both believed.
-- Open conflicts of either kind reduce effective_mean via the
-- continuous competition model [Fix 13]:
--   effective_mean = posterior / (1 + Σ opponent_posterior + penalties)
-- which equals the unopposed posterior when no conflicts are open, and
-- is strictly monotone decreasing in opposition (the v0.8 form let a
-- feeble opponent RAISE effective belief). Resolving a conflict
-- restores effective_mean.
--
-- [Fix 16] Note: identical atoms can no longer be duplicated (one atom
-- = one row), so a competing claim must genuinely differ — here, the
-- opposing claim carries its own temporal scope.
-- ════════════════════════════════════════════════════════════

-- ── G1. Insert a contradictory claim ─────────────────────────
-- A bad source asserts Lovelace was NOT a mathematician (it claims the
-- role-holding with very low belief) for the 1830–1850 window.
-- Scope arg matches C3 (no_scope).
-- statement_kind = 'empirical' on the contradictory claim.
-- [Fix 16] The C3 atom (t_kind='always') cannot simply be re-inserted
-- with different belief — content_hash forbids duplicate atoms. The
-- opposing claim is a DISTINCT atom (interval scope) whose time window
-- overlaps C3's, which is exactly what detect_conflicts() pass 1 looks
-- for.

INSERT INTO objects (id, kind, canonical_name, display_name)
VALUES (
    stable_uuid('unreliable_blog', 'source'),
    'source', 'unreliable_blog', 'Unreliable Blog Post'
) ON CONFLICT (canonical_name, kind) DO NOTHING;

INSERT INTO source_credibility (source_id, context_id, alpha, beta)
VALUES (
    stable_uuid('unreliable_blog', 'source'),
    stable_uuid('domain_history',  'context'),
    2.0, 5.0
) ON CONFLICT DO NOTHING;

DO $$
DECLARE
    opposing_stmt uuid;
BEGIN
    INSERT INTO statements (
        predicate_id, object_args,
        belief_alpha, belief_beta,
        statement_kind, interpretation,
        t_kind, t_start, t_end,
        context_id, derivation_type
    ) VALUES (
        stable_uuid('has_role', 'predicate'),
        ARRAY[
            stable_uuid('ada_lovelace',  'entity'),
            stable_uuid('mathematician', 'entity'),
            stable_uuid('no_scope',      'entity')
        ],
        2.0, 5.0,
        'empirical', 'ontological',
        'interval',
        ROW(year_to_jd(1830), year_to_jd(1829), year_to_jd(1831), 'year')::fuzzy_time,
        ROW(year_to_jd(1850), year_to_jd(1849), year_to_jd(1851), 'year')::fuzzy_time,
        stable_uuid('reality', 'context'),
        'source_ingested'
    )
    RETURNING id INTO opposing_stmt;

    INSERT INTO attestations (statement_id, source_id)
    VALUES (opposing_stmt, stable_uuid('unreliable_blog', 'source'));

    RAISE NOTICE 'Opposing statement %: belief_mean ≈ 0.286 (low-credibility source)',
        opposing_stmt;
END $$;


-- ── G2. Detect conflicts via detect_conflicts() ───────────────
-- detect_conflicts() uses CI non-overlap as the criterion and
-- populates severity (normalised CI gap) on each inserted row.
-- Temporal overlap guard prevents false positives from disjoint
-- time windows. Safe to call repeatedly after bulk ingestion.

SELECT detect_conflicts(stable_uuid('reality', 'context')) AS new_conflicts_inserted;
-- Expect: 1 (the mathematician-claim pair)

-- Inspect newly detected conflicts including severity.
SELECT
    cf.id,
    cf.conflict_kind,
    pa.canonical_name                         AS predicate,
    round(sba.belief_mean::numeric, 4)        AS belief_a,
    round(sbb.belief_mean::numeric, 4)        AS belief_b,
    round(ba.ci_high::numeric, 4)             AS ci_high_a,
    round(bb.ci_low::numeric, 4)              AS ci_low_b,
    round(cf.severity::numeric, 4)            AS severity,
    cf.resolved
FROM conflicts cf
JOIN statements    sa   ON sa.id   = cf.statement_a
JOIN statements    sb_s ON sb_s.id = cf.statement_b
JOIN objects       pa   ON pa.id   = sa.predicate_id
JOIN statement_belief sba ON sba.id = cf.statement_a
JOIN statement_belief sbb ON sbb.id = cf.statement_b
JOIN statement_belief ba  ON ba.id  = cf.statement_a
JOIN statement_belief bb  ON bb.id  = cf.statement_b
WHERE cf.resolved = false
  AND cf.conflict_kind = 'direct_negation'
ORDER BY cf.severity DESC, cf.created_at DESC
LIMIT 5;
-- Expect: severity > 0; ci_high_a < ci_low_b (CIs do not overlap).

-- While the conflict is OPEN, the competition model [Fix 13] suppresses
-- both sides in proportion to the other's posterior:
--   effective_mean = posterior_mean / (1 + Σ opponent_posterior_mean)
SELECT
    s.t_kind,
    round(seb.posterior_mean::numeric, 4) AS posterior_mean,
    round(seb.effective_mean::numeric, 4) AS effective_mean,
    seb.open_conflict_count
FROM statements s
JOIN statement_effective_belief seb ON seb.id = s.id
WHERE s.predicate_id   = stable_uuid('has_role', 'predicate')
  AND s.object_args[1] = stable_uuid('ada_lovelace',  'entity')
  AND s.object_args[2] = stable_uuid('mathematician', 'entity')
ORDER BY seb.effective_mean DESC;
-- Expect: both rows have open_conflict_count = 1 and
-- effective_mean < posterior_mean (≈ 0.80 → 0.58 and ≈ 0.38 → 0.21
-- with the seeded numbers). Each side is divided by (1 + the other's
-- posterior): the ordering is preserved, the strong claim stays above
-- the 0.5 threshold, and the suppression is continuous in opponent
-- mass — as the opponent's posterior approaches 0, effective_mean
-- approaches the unopposed posterior exactly (in v0.8 the model was
-- discontinuous there, and a weak opponent paradoxically RAISED the
-- strong claim's effective belief).


-- ── G3. Register an additional manual conflict ────────────────
-- detect_conflicts() covers CI-based cases. Register conflicts
-- manually when domain knowledge identifies evidential opposition
-- even where CIs overlap.
-- [Fix 18] uq_conflicts_pair allows at most ONE direct_negation row per
-- statement pair: since G2 already detected this exact pair, the bare
-- ON CONFLICT DO NOTHING below is absorbed by the unique index and this
-- insert is a silent no-op. Manual registration matters for pairs that
-- detect_conflicts() does NOT find (overlapping CIs) — the mechanics
-- are identical.

DO $$
DECLARE
    high_id uuid;
    low_id  uuid;
BEGIN
    SELECT id INTO high_id
    FROM statements
    WHERE predicate_id   = stable_uuid('has_role', 'predicate')
      AND object_args[1] = stable_uuid('ada_lovelace',  'entity')
      AND object_args[2] = stable_uuid('mathematician', 'entity')
    ORDER BY belief_mean DESC LIMIT 1;

    SELECT id INTO low_id
    FROM statements
    WHERE predicate_id   = stable_uuid('has_role', 'predicate')
      AND object_args[1] = stable_uuid('ada_lovelace',  'entity')
      AND object_args[2] = stable_uuid('mathematician', 'entity')
    ORDER BY belief_mean ASC LIMIT 1;

    IF high_id IS NOT NULL AND low_id IS NOT NULL AND high_id <> low_id THEN
        INSERT INTO conflicts (statement_a, statement_b, conflict_kind)
        VALUES (high_id, low_id, 'direct_negation')
        ON CONFLICT DO NOTHING;
        RAISE NOTICE 'Manual conflict upsert attempted: % (high) vs % (low) '
            '(a no-op here — the pair already has a detected direct_negation row)',
            high_id, low_id;
    END IF;
END $$;


-- ── G4. Resolve a conflict ────────────────────────────────────

UPDATE conflicts
SET resolved        = true,
    resolution_note = 'Unreliable blog (α=2, β=5, mean≈0.286) outweighed '
                      'by Wikidata + Lovelace biography (α≈14.9, β≈2, mean≈0.88). '
                      'High-belief statement retained; low-belief statement '
                      'remains in KB with its belief unchanged for audit purposes.'
WHERE conflict_kind = 'direct_negation'
  AND statement_a IN (
      SELECT id FROM statements
      WHERE predicate_id   = stable_uuid('has_role', 'predicate')
        AND object_args[1] = stable_uuid('ada_lovelace',  'entity')
        AND object_args[2] = stable_uuid('mathematician', 'entity')
  );


-- ── G5. Soft domain violation example ────────────────────────
-- trg_z_soft_domain_check fires AFTER INSERT OR UPDATE when a
-- statement's arg is not a confirmed member of the predicate's
-- expected arg type (resolved transitively via subtype_of).
-- Hard violations raise an exception; soft violations insert a
-- type_mismatch conflict (statement_a = statement_b = the statement).
-- The check fires on UPDATE too — swapping object_args to an invalid
-- value post-insertion is also caught.
--
-- Example: agent_of expects an animate entity as arg[1].
-- difference_engine is an artifact (concrete), not animate.
-- domain_strictness of agent_of = 'soft' → type_mismatch conflict.

DO $$
DECLARE
    bad_stmt uuid;
BEGIN
    INSERT INTO statements (
        predicate_id, object_args,
        belief_alpha, belief_beta,
        statement_kind, t_kind, context_id, derivation_type
    ) VALUES (
        stable_uuid('agent_of', 'predicate'),
        ARRAY[
            stable_uuid('difference_engine', 'entity'),  -- NOT animate
            stable_uuid('ada_lovelace',      'entity')
        ],
        3.0, 2.0,
        'empirical', 'always',
        stable_uuid('reality', 'context'),
        'source_ingested'
    )
    RETURNING id INTO bad_stmt;

    RAISE NOTICE 'Soft domain violation statement inserted: %', bad_stmt;
    RAISE NOTICE 'A type_mismatch conflict should now exist.';
END $$;

-- Inspect the auto-generated type_mismatch conflict.
-- statement_a = statement_b = the offending statement (self-referential).
SELECT
    cf.id,
    cf.conflict_kind,
    cf.resolution_note,
    cf.resolved,
    sa.predicate_id,
    sa.object_args
FROM conflicts cf
JOIN statements sa ON sa.id = cf.statement_a
WHERE cf.conflict_kind = 'type_mismatch'
  AND cf.statement_a   = cf.statement_b
ORDER BY cf.created_at DESC
LIMIT 3;
-- Expect: one row, conflict_kind='type_mismatch', self-referential.
-- resolution_note describes which arg and expected type were mismatched.


-- ── G6. Effective belief: competition model in action ─────────
-- [Fix 13] With open conflicts, effective_mean is computed as:
--   posterior_mean / (1 + Σ opponent_posterior_mean + Σ penalties)
-- This shows posterior_mean (base) vs effective_mean (post-competition).
-- After G4 resolves the conflict, effective_mean returns to
-- posterior_mean exactly — the model is continuous at zero opposition.

SELECT
    round(seb.raw_mean::numeric, 4)             AS raw_mean,
    round(seb.posterior_mean::numeric, 4)       AS posterior_mean,
    round(seb.effective_mean::numeric, 4)        AS effective_mean,
    seb.open_conflict_count,
    round(seb.conflict_severity::numeric, 4)     AS max_conflict_severity
FROM statements s
JOIN statement_effective_belief seb ON seb.id = s.id
WHERE s.predicate_id   = stable_uuid('has_role', 'predicate')
  AND s.object_args[1] = stable_uuid('ada_lovelace',  'entity')
  AND s.object_args[2] = stable_uuid('mathematician', 'entity')
ORDER BY s.belief_mean DESC LIMIT 1;
-- Expect: effective_mean < posterior_mean while the conflict is open;
-- equal again once resolved.


-- ── G7. Functional value conflict [Fix 17] ─────────────────────
-- C8 asserted has_value(difference_engine, component_count, 25000).
-- has_value is wired is_functional in the predicates kernel: the
-- (entity, attribute) pair determines the value. A second believed
-- claim with a DIFFERENT value is a genuine real-world contradiction —
-- the kind the v0.8 same-atom scan could never see.

INSERT INTO statements (
    predicate_id, object_args, literal_args,
    belief_alpha, belief_beta,
    statement_kind, t_kind, context_id, derivation_type
) VALUES (
    stable_uuid('has_value', 'predicate'),
    ARRAY[
        stable_uuid('difference_engine', 'entity'),
        stable_uuid('component_count',   'entity')
    ],
    '[{"pos":2,"type":"integer","value":8000}]'::jsonb,
    6.0, 2.0,
    'empirical', 'always',
    stable_uuid('reality', 'context'),
    'source_ingested'
)
ON CONFLICT (content_hash) DO NOTHING;

SELECT detect_conflicts(stable_uuid('reality', 'context')) AS new_value_conflicts;
-- Expect: 1 (the component_count pair, conflict_kind='value_conflict').

-- Both claims are suppressed in proportion to the other's posterior:
SELECT
    s.literal_args -> 0 ->> 'value'              AS claimed_value,
    round(seb.posterior_mean::numeric, 4)        AS posterior_mean,
    round(seb.effective_mean::numeric, 4)        AS effective_mean,
    seb.open_conflict_count
FROM statements s
JOIN statement_effective_belief seb ON seb.id = s.id
WHERE s.predicate_id = stable_uuid('has_value', 'predicate')
  AND s.object_args  = ARRAY[stable_uuid('difference_engine', 'entity'),
                             stable_uuid('component_count',   'entity')]
ORDER BY seb.effective_mean DESC;
-- Expect: two rows, each with open_conflict_count = 1 and
-- effective_mean < posterior_mean; the better-supported 25000 claim
-- stays ahead. A reasoner reading effective_mean sees the dispute
-- without either claim being deleted.


-- ════════════════════════════════════════════════════════════
-- PART H: AGGREGATE VIEWS AND INTROSPECTION
-- ════════════════════════════════════════════════════════════

-- ── H1. Statement counts by t_kind, derivation_type, kind ────

SELECT
    t_kind,
    statement_kind,
    derivation_type,
    count(*)                                        AS n_statements,
    round(avg(seb.effective_mean)::numeric, 4)      AS avg_effective_belief
FROM statements s
JOIN statement_effective_belief seb ON seb.id = s.id
GROUP BY t_kind, statement_kind, derivation_type
ORDER BY t_kind, statement_kind, derivation_type;
-- avg_effective_belief is NULL for rule statements (not in belief pipeline).


-- ── H2. tell_about(person) ───────────────────────────────────
-- "What does the KB know about person?"
-- tell_about() returns all statements where the entity appears in
-- any arg position, resolved to canonical names, ordered by
-- effective_mean. Rule statements are excluded. Sentinel args are
-- excluded by default (p_include_sentinels=false).

SELECT
    predicate,
    arg_names,
    round(effective_mean::numeric, 4)    AS effective_belief,
    round(raw_mean::numeric, 4)          AS raw_belief,
    open_conflict_count,
    statement_kind,
    t_kind,
    derivation_type
FROM tell_about(
    stable_uuid('person', 'entity'),
    stable_uuid('reality', 'context'),
    0.0,        -- p_threshold
    NULL,       -- p_time: no temporal filter
    false       -- p_include_sentinels: exclude statements with sentinel args
)
ORDER BY effective_mean DESC, predicate;


-- ── H3. tell_about(ada_lovelace) ─────────────────────────────
-- Primary "what do we know about X?" query for a named individual.

SELECT
    predicate,
    arg_names,
    round(effective_mean::numeric, 4)    AS effective_belief,
    round(raw_mean::numeric, 4)          AS raw_belief,
    open_conflict_count,
    statement_kind,
    t_kind,
    derivation_type,
    t_start,
    t_end
FROM tell_about(
    stable_uuid('ada_lovelace', 'entity'),
    stable_uuid('reality', 'context'),
    0.0
)
ORDER BY effective_mean DESC;
-- Expect (with default p_include_sentinels=false):
-- • is_a(ada_lovelace, person)             ← included
-- • is_a(ada_lovelace, mammal) [derived]   ← included
-- • has_role(ada_lovelace, programmer, difference_engine) ← included
-- EXCLUDED because any arg is a sentinel (no_scope, no_period):
-- • has_role(ada_lovelace, mathematician, no_scope)
-- • located_in(ada_lovelace, london, no_period)
-- See H5 (p_include_sentinels=true) to see those rows.


-- ── H4. tell_about with p_time ───────────────────────────────
-- Restrict to statements whose temporal scope includes a specific
-- historical moment. What was true about Lovelace in 1842?
-- Eternal/always statements always included; interval statements
-- included only if they contain 1842; point statements use
-- granularity-aware overlap (point_statement_contains).

SELECT
    predicate,
    arg_names,
    round(effective_mean::numeric, 4)    AS effective_belief,
    statement_kind,
    t_kind,
    t_start,
    t_end
FROM tell_about(
    stable_uuid('ada_lovelace', 'entity'),
    stable_uuid('reality', 'context'),
    0.0,
    '1842-06-01 00:00:00+00'::timestamptz   -- p_time
)
ORDER BY effective_mean DESC;
-- Expect: eternal/always statements included.
-- has_role(ada_lovelace, programmer, difference_engine) [1842–1843] → included.
-- located_in(ada_lovelace, london, no_period) [point 1815] → excluded
--   (1842 is outside the 1815 year window).


-- ── H5. tell_about with p_include_sentinels ──────────────────
-- By default sentinel args are excluded (p_include_sentinels=false).
-- Passing true includes them — useful for diagnostic queries.

SELECT
    predicate,
    arg_names,
    round(effective_mean::numeric, 4)    AS effective_belief,
    t_kind
FROM tell_about(
    stable_uuid('ada_lovelace', 'entity'),
    stable_uuid('reality', 'context'),
    0.0,
    NULL,
    true    -- p_include_sentinels: show everything
)
ORDER BY effective_mean DESC;
-- Compare with H3 to see which rows contain sentinel args.


-- ── H6. tell_about with context filter ───────────────────────

SELECT
    predicate,
    arg_names,
    round(effective_mean::numeric, 4)  AS effective_belief,
    statement_kind,
    t_kind
FROM tell_about(
    stable_uuid('difference_engine', 'entity'),
    stable_uuid('domain_technology', 'context'),
    0.5
)
ORDER BY effective_mean DESC;


-- ── H7. Source credibility overview ──────────────────────────

SELECT
    o.canonical_name                          AS source,
    c.canonical_name                          AS context,
    round(scs.mean::numeric, 4)               AS credibility_mean,
    round(scs.ci_low::numeric, 4)             AS ci_low,
    round(scs.ci_high::numeric, 4)            AS ci_high,
    round(scs.evidence_strength::numeric, 1)  AS evidence_strength,
    scs.is_protected
FROM source_credibility_score scs
JOIN objects o ON o.id = scs.source_id
JOIN objects c ON c.id = scs.context_id
ORDER BY scs.mean DESC, o.canonical_name;


-- ── H8. Open conflicts with competition model impact ─────────
-- Shows severity (diagnostic) alongside effective_mean (actual impact).
-- The competition model uses credibility sums, not the severity score.

SELECT
    cf.id,
    cf.conflict_kind,
    round(cf.severity::numeric, 4)                 AS severity,
    pa.canonical_name                               AS predicate_a,
    round(seba.credibility_adjusted::numeric, 4)   AS cred_adj_a,
    round(seba.effective_mean::numeric, 4)          AS effective_mean_a,
    round(seba.raw_mean::numeric, 4)                AS raw_mean_a,
    round(sebb.effective_mean::numeric, 4)          AS effective_mean_b,
    round(sebb.raw_mean::numeric, 4)                AS raw_mean_b,
    cf.resolved,
    cf.created_at
FROM conflicts cf
JOIN statements    sa   ON sa.id   = cf.statement_a
JOIN statements    sb_s ON sb_s.id = cf.statement_b
JOIN objects       pa   ON pa.id   = sa.predicate_id
JOIN statement_effective_belief seba ON seba.id = cf.statement_a
JOIN statement_effective_belief sebb ON sebb.id = cf.statement_b
WHERE cf.resolved = false
ORDER BY cf.severity DESC NULLS LAST, cf.created_at;
-- Expect: effective_mean_a < credibility_adjusted_a when conflict is open.


-- ── H9. Equivalent objects ────────────────────────────────────

SELECT
    a.canonical_name                               AS object_a,
    b.canonical_name                               AS object_b,
    round((oe.alpha / (oe.alpha + oe.beta))::numeric, 4) AS equiv_belief,
    oe.alpha + oe.beta                             AS evidence_strength
FROM object_equivalence oe
JOIN objects a ON a.id = oe.object_a
JOIN objects b ON b.id = oe.object_b
ORDER BY equiv_belief DESC;
-- Should include: is_a ↔ instance_of (seeded by predicates file)


-- ════════════════════════════════════════════════════════════
-- PART I: v0.8 ENFORCEMENT DEMONSTRATIONS
-- These examples show the BEFORE triggers that reject invalid inserts.
-- Each is wrapped in a DO block so the surrounding transaction survives.
-- ════════════════════════════════════════════════════════════

-- ── I1. trg_d: sentinel args blocked in structural predicates ─
-- is_a, subtype_of, same_as, different_from, equivalent_to cannot
-- accept sentinel objects (no_scope, no_period, unknown, true, false).
-- Sentinels are inference-opaque and must not acquire type_membership.

DO $$
BEGIN
    -- Attempt is_a with 'unknown' as a sentinel arg — should fail.
    INSERT INTO statements (
        predicate_id, object_args,
        belief_alpha, belief_beta,
        statement_kind, t_kind, context_id, derivation_type
    ) VALUES (
        stable_uuid('is_a', 'predicate'),
        ARRAY[
            stable_uuid('unknown',      'entity'),  -- sentinel
            stable_uuid('truth_value',  'entity')
        ],
        1000.0, 0.001,
        'empirical', 'eternal',
        stable_uuid('reality', 'context'),
        'user_asserted'
    );
    RAISE NOTICE 'ERROR: insert should have been rejected by trg_d.';
EXCEPTION WHEN others THEN
    RAISE NOTICE 'CORRECT: trg_d blocked is_a(unknown, truth_value): %',
        SQLERRM;
END $$;


-- ── I2. trg_c: is_a target in role hierarchy is rejected ──────
-- is_a cannot target objects in the role hierarchy. Use has_role instead.
-- trg_c_enforce_is_a_target walks the role hierarchy via recursive CTE.

DO $$
BEGIN
    -- Attempt is_a(ada_lovelace, mathematician) — mathematician is a role subtype.
    INSERT INTO statements (
        predicate_id, object_args,
        belief_alpha, belief_beta,
        statement_kind, t_kind, context_id, derivation_type
    ) VALUES (
        stable_uuid('is_a', 'predicate'),
        ARRAY[
            stable_uuid('ada_lovelace',  'entity'),
            stable_uuid('mathematician', 'entity')   -- role-hierarchy target
        ],
        1000.0, 0.001,
        'empirical', 'eternal',
        stable_uuid('reality', 'context'),
        'user_asserted'
    );
    RAISE NOTICE 'ERROR: insert should have been rejected by trg_c.';
EXCEPTION WHEN others THEN
    RAISE NOTICE 'CORRECT: trg_c blocked is_a(ada_lovelace, mathematician): %',
        SQLERRM;
    RAISE NOTICE 'Use has_role(ada_lovelace, mathematician, no_scope) instead.';
END $$;


-- ── I3. trg_b: wrong statement_kind for predicate rejected ────
-- correlated_with requires statement_kind='statistical'.
-- typical_of requires statement_kind='statistical'.
-- implies requires statement_kind='rule'.
-- subtype_of, disjoint_with etc. require statement_kind='ontological'.

DO $$
BEGIN
    -- Attempt correlated_with with 'empirical' kind — should fail.
    INSERT INTO statements (
        predicate_id, object_args,
        belief_alpha, belief_beta,
        statement_kind, t_kind, context_id, derivation_type
    ) VALUES (
        stable_uuid('correlated_with', 'predicate'),
        ARRAY[
            stable_uuid('mathematics', 'entity'),
            stable_uuid('logic',       'entity')
        ],
        8.0, 2.0,
        'empirical',   -- wrong: should be 'statistical'
        'always',
        stable_uuid('reality', 'context'),
        'user_asserted'
    );
    RAISE NOTICE 'ERROR: insert should have been rejected by trg_b.';
EXCEPTION WHEN others THEN
    RAISE NOTICE 'CORRECT: trg_b blocked correlated_with with empirical kind: %',
        SQLERRM;
END $$;


-- ── I4. trg_e: subtype_of cycle rejected ──────────────────────
-- trg_e_enforce_subtype_acyclicity rejects any subtype_of insertion
-- that would create a cycle. Depth-50 bounded search.

DO $$
BEGIN
    -- person ⊂ mammal ⊂ animal ⊂ organism — person is already an ancestor
    -- of nothing in that chain. Try something that would create a cycle:
    -- attempt organism ⊂ person (person is already a subtype of organism).
    INSERT INTO statements (
        predicate_id, object_args,
        belief_alpha, belief_beta,
        statement_kind, t_kind, context_id, derivation_type
    ) VALUES (
        stable_uuid('subtype_of', 'predicate'),
        ARRAY[
            stable_uuid('organism', 'entity'),  -- proposed subtype
            stable_uuid('person',   'entity')   -- proposed supertype
        ],
        -- person → mammal → animal → organism; organism ⊂ person would cycle
        1000.0, 0.001,
        'ontological', 'eternal',
        stable_uuid('reality', 'context'),
        'user_asserted'
    );
    RAISE NOTICE 'ERROR: cycle should have been rejected by trg_e.';
EXCEPTION WHEN others THEN
    RAISE NOTICE 'CORRECT: trg_e blocked cyclic subtype_of(organism, person): %',
        SQLERRM;
END $$;


-- ── I5. trg_za: constraint disjointness violation rejected ────
-- trg_za_enforce_disjointness fires AFTER INSERT on is_a/instance_of.
-- When the asserted type's disjointness axioms include a 'constraint'
-- row and the entity already has the disjoint type in type_membership,
-- an exception is raised.
-- Note: incompatibility disjointness does NOT block the insert.

DO $$
BEGIN
    -- difference_engine is already is_a artifact (concrete).
    -- abstract ⊥ concrete has disjointness_kind = 'constraint'.
    -- Attempting is_a(difference_engine, abstract) should fail.
    INSERT INTO statements (
        predicate_id, object_args,
        belief_alpha, belief_beta,
        statement_kind, t_kind, context_id, derivation_type
    ) VALUES (
        stable_uuid('is_a', 'predicate'),
        ARRAY[
            stable_uuid('difference_engine', 'entity'),
            stable_uuid('abstract',          'entity')
        ],
        1000.0, 0.001,
        'empirical', 'eternal',
        stable_uuid('reality', 'context'),
        'user_asserted'
    );
    RAISE NOTICE 'ERROR: disjointness constraint should have been enforced by trg_za.';
EXCEPTION WHEN others THEN
    RAISE NOTICE 'CORRECT: trg_za blocked is_a(difference_engine, abstract): %',
        SQLERRM;
END $$;

-- Show that the incompatibility variant (person ⊥ institution) does NOT block.
-- (This is a data scenario, not a live insert in these examples — just a note.)
-- person ⊥ institution has disjointness_kind = 'incompatibility'.
-- Inserting is_a(X, person) when X is already is_a institution would NOT
-- raise an exception; it would instead scale the competition-model denominator
-- in statement_effective_belief, reducing effective_mean for both sides.


-- ── I6. update_belief: ontological guard ──────────────────────
-- update_belief() rejects updates to ontological statements without
-- p_override=true. Ontological belief is fixed at assertion time
-- and must not drift from passive evidence accumulation.

DO $$
DECLARE
    ont_stmt uuid;
BEGIN
    -- Find a kernel subtype_of statement (ontological).
    SELECT id INTO ont_stmt
    FROM statements
    WHERE predicate_id   = stable_uuid('subtype_of', 'predicate')
      AND object_args[1] = stable_uuid('person',     'entity')
      AND object_args[2] = stable_uuid('mammal',     'entity')
    LIMIT 1;

    IF ont_stmt IS NULL THEN
        RAISE NOTICE 'subtype_of(person, mammal) not found; skipping.';
        RETURN;
    END IF;

    -- Attempt without override — should fail.
    BEGIN
        PERFORM update_belief(ont_stmt, 1.0, true, false);
        RAISE NOTICE 'ERROR: should have been rejected.';
    EXCEPTION WHEN others THEN
        RAISE NOTICE 'CORRECT: update_belief blocked without p_override: %',
            SQLERRM;
    END;

    -- With override=true succeeds (deliberate human correction).
    PERFORM update_belief(ont_stmt, 0.001, true, true);
    RAISE NOTICE 'OK: update_belief with p_override=true accepted.';

    -- Restore original belief.
    UPDATE statements
       SET belief_alpha = 1000.0,
           belief_beta  = 0.001,
           updated_at   = now()
     WHERE id = ont_stmt;
END $$;


-- ════════════════════════════════════════════════════════════
-- PART J: VALIDATE_KB_INTEGRITY AND TRUTH_STATUS
-- ════════════════════════════════════════════════════════════

-- ── J1. validate_kb_integrity() ───────────────────────────────
-- Runs a suite of consistency checks and returns violations.
-- Pass p_all=true to see all checks including passing ones.
-- Should be run after bulk ingestion alongside detect_conflicts().

SELECT
    check_name,
    violation_count,
    detail
FROM validate_kb_integrity(
    stable_uuid('reality', 'context'),
    true    -- p_all: show all checks, even passing ones
)
ORDER BY check_name;
-- Expect: all violation_count = 0 on a freshly loaded KB.
-- Checks covered:
--   statement_args_sync      — object_args mirrored in statement_args
--   type_membership_orphans  — type_membership backed by is_a
--   missing_provenance       — forward_chained/abduced have dependencies
--   subtype_of_cycles        — no type is its own ancestor
--   sentinel_in_structural   — no sentinels in structural predicates
--   predicate_kind_mismatch  — predicate ↔ statement_kind consistency
--   dependency_cycles        — no cycles in statement_dependencies
--   disjointness_kind_misuse — disjointness_kind only on disjoint_with


-- ── J2. validate_kb_integrity() — violations only ────────────
-- Default p_all=false returns only checks with violations.

SELECT check_name, violation_count, detail
FROM validate_kb_integrity()
ORDER BY violation_count DESC;
-- Expect: empty result on a healthy KB.


-- ── J3. truth_status() ───────────────────────────────────────
-- [Fix 20] Four states:
-- 'supported'    — at least one statement holds above threshold.
-- 'contradicted' — statements exist, none clears the threshold, AND at
--                  least one is party to an OPEN direct_negation /
--                  value_conflict: the claim is actively opposed.
-- 'insufficient' — statements exist, none clears the threshold, and
--                  there is no open opposition: merely under-supported.
--                  (v0.8 mislabelled this case 'contradicted', reading
--                  weakness as evidence of negation.)
-- 'unknown'      — no statements at all (genuine open-world: no claim made).

-- Case 1: supported — we have strong evidence.
SELECT truth_status(
    stable_uuid('is_a', 'predicate'),
    ARRAY[
        stable_uuid('ada_lovelace', 'entity'),
        stable_uuid('person',       'entity')
    ],
    stable_uuid('reality', 'context'),
    NULL,   -- p_time
    0.5
) AS status;
-- Expect: 'supported'

-- Case 2: unknown — we have never made any claim about this.
SELECT truth_status(
    stable_uuid('is_a', 'predicate'),
    ARRAY[
        stable_uuid('ada_lovelace', 'entity'),
        stable_uuid('institution',  'entity')
    ],
    stable_uuid('reality', 'context'),
    NULL,
    0.5
) AS status;
-- Expect: 'unknown' (open-world: absence of evidence ≠ false)

-- Case 3: contradicted — the low-belief claim from G1 is below threshold.
-- After conflict is resolved in G4, the high-belief statement dominates.
SELECT truth_status(
    stable_uuid('has_role', 'predicate'),
    ARRAY[
        stable_uuid('ada_lovelace',  'entity'),
        stable_uuid('mathematician', 'entity'),
        stable_uuid('no_scope',      'entity')
    ],
    stable_uuid('reality', 'context'),
    NULL,
    0.5
) AS status;
-- Expect: 'supported' (high-belief statement clears threshold).
-- Lower the threshold past the low-belief statement's effective_mean:
SELECT truth_status(
    stable_uuid('has_role', 'predicate'),
    ARRAY[
        stable_uuid('ada_lovelace',  'entity'),
        stable_uuid('mathematician', 'entity'),
        stable_uuid('no_scope',      'entity')
    ],
    stable_uuid('reality', 'context'),
    NULL,
    0.99   -- very high threshold
) AS status;
-- Expect: 'insufficient' — statements exist and none clears 0.99, but
-- G4 already RESOLVED the direct_negation between them, so there is no
-- open opposition: under-supported, not contradicted. (Before G4, this
-- same call would have returned 'contradicted'.)

-- Case 4 [Fix 20]: insufficient — a weak, UNOPPOSED claim.
-- agent_of(difference_engine, ada_lovelace) was inserted in G5 at
-- belief ≈ 0.6 and has no direct_negation/value_conflict rows (only a
-- self-referential type_mismatch). Above a 0.9 threshold it is merely
-- under-supported, not contradicted.
SELECT truth_status(
    stable_uuid('agent_of', 'predicate'),
    ARRAY[
        stable_uuid('difference_engine', 'entity'),
        stable_uuid('ada_lovelace',      'entity')
    ],
    stable_uuid('reality', 'context'),
    NULL,
    0.9
) AS status;
-- Expect: 'insufficient' — v0.8 would have said 'contradicted' here,
-- manufacturing opposition out of mere weakness.

-- Case 5 [Fix 20]: contradicted — live opposition.
-- The G7 value_conflict on component_count is still OPEN: two believed
-- claims, mutually suppressed below the 0.5 threshold by the
-- competition model. This is what 'contradicted' is for.
SELECT truth_status(
    stable_uuid('has_value', 'predicate'),
    ARRAY[
        stable_uuid('difference_engine', 'entity'),
        stable_uuid('component_count',   'entity')
    ],
    stable_uuid('reality', 'context'),
    NULL,
    0.5
) AS status;
-- Expect: 'contradicted' — claims exist, none clears the threshold, and
-- an open value_conflict actively opposes them.


-- ════════════════════════════════════════════════════════════
-- PART K: PYTHON REFERENCE (psycopg2 / asyncpg patterns)
-- ════════════════════════════════════════════════════════════

/*
import psycopg2

conn = psycopg2.connect("dbname=your_database")
cur  = conn.cursor()

# ── Replicate stable_uuid() in Python ────────────────────────
import hashlib
def stable_uuid(name: str, kind: str) -> str:
    key = f"{name}:{kind}"
    h   = hashlib.md5(key.encode()).hexdigest()
    return f"{h[:8]}-{h[8:12]}-4{h[13:16]}-{h[16:20]}-{h[20:32]}"

# ── Boolean query using effective belief ─────────────────────
# Use statement_effective_belief for credibility-adjusted, competition-
# normalised belief. effective_mean is NULL for rule statements.
cur.execute("""
    SELECT seb.raw_mean, seb.credibility_adjusted,
           seb.effective_mean, seb.open_conflict_count
    FROM statements s
    JOIN statement_effective_belief seb ON seb.id = s.id
    WHERE s.predicate_id = %s
      AND s.object_args  = ARRAY[%s::uuid, %s::uuid]
""", (
    stable_uuid('subtype_of', 'predicate'),
    stable_uuid('mammal',     'entity'),
    stable_uuid('animal',     'entity'),
))
row = cur.fetchone()
if row:
    print(f"raw={row[0]:.4f} cred_adj={row[1]:.4f} "
          f"effective={row[2]:.4f} open_conflicts={row[3]}")

# ── Temporal query ────────────────────────────────────────────
cur.execute("""
    SELECT * FROM holds_at(%s, ARRAY[%s::uuid, %s::uuid, %s::uuid],
                           %s::timestamptz, %s, %s, %s, %s)
""", (
    stable_uuid('affiliated_with',         'predicate'),
    stable_uuid('charles_babbage',         'entity'),
    stable_uuid('university_of_cambridge', 'entity'),
    stable_uuid('lucasian_professor',      'entity'),
    '1835-06-01',
    stable_uuid('reality', 'context'),
    'open_world',
    0.5,   # p_threshold (applied to effective_mean)
    0.0,   # p_min_evidence
))
for row in cur.fetchall():
    print(f"statement_id={row[0]}  effective_belief={row[1]:.4f}  evidence={row[2]:.1f}")

# ── Assert a type via is_a ────────────────────────────────────
# statement_kind = 'empirical' for individual classifications.
# NOTE: target must NOT be in the role hierarchy (trg_c enforces).
# NOTE: target must NOT be a sentinel (trg_d enforces).
cur.execute("""
    INSERT INTO statements (
        predicate_id, object_args, belief_alpha, belief_beta,
        statement_kind, t_kind, context_id, derivation_type
    ) VALUES (
        %s, ARRAY[%s::uuid, %s::uuid],
        1000.0, 0.001, 'empirical', 'eternal', %s, 'user_asserted'
    ) ON CONFLICT DO NOTHING
""", (
    stable_uuid('is_a',        'predicate'),
    stable_uuid('my_entity',   'entity'),
    stable_uuid('person',      'entity'),
    stable_uuid('reality',     'context'),
))
conn.commit()
# type_membership now has a row for (my_entity, person) automatically.

# ── located_in with no_period ─────────────────────────────────
# Use no_period for the time_period arg when no named period is intended.
# Use no_scope for role-scope args (has_role third arg).
# For t_kind='point', t_start must be set and t_end must be NULL.
cur.execute("""
    INSERT INTO statements (
        predicate_id, object_args, belief_alpha, belief_beta,
        statement_kind, t_kind, t_start, context_id, derivation_type
    ) VALUES (
        %s,
        ARRAY[%s::uuid, %s::uuid, %s::uuid],
        10.0, 1.0,
        'empirical', 'point',
        ROW(year_to_jd(1791), year_to_jd(1791), year_to_jd(1792), 'year')::fuzzy_time,
        %s, 'source_ingested'
    )
""", (
    stable_uuid('located_in',  'predicate'),
    stable_uuid('my_person',   'entity'),
    stable_uuid('london',      'entity'),
    stable_uuid('no_period',   'entity'),   # no named period is the arg
    stable_uuid('reality',     'context'),
))
conn.commit()

# ── tell_about() with p_time and p_include_sentinels ─────────
# p_time filters to statements holding at that moment.
# p_include_sentinels=False (default) excludes statements where any
# object arg is a sentinel; True includes them for diagnostic use.
cur.execute("""
    SELECT predicate, arg_names, effective_mean, raw_mean,
           statement_kind, t_kind, derivation_type
    FROM tell_about(%s, %s, %s, %s, %s)
    ORDER BY effective_mean DESC
""", (
    stable_uuid('ada_lovelace', 'entity'),
    stable_uuid('reality',      'context'),
    0.0,            # p_threshold
    '1842-06-01',   # p_time
    False,          # p_include_sentinels
))
for row in cur.fetchall():
    print(f"{row[0]}({', '.join(row[1])}) effective={row[2]:.4f} kind={row[4]}")

# ── why() ─────────────────────────────────────────────────────
derived_stmt_id = "..."   # UUID of a forward_chained statement
cur.execute("""
    SELECT depth, predicate, arg_names, belief_mean, effective_mean,
           rule_name, edge_weight, statement_kind
    FROM why(%s)
    ORDER BY depth, statement_id
""", (derived_stmt_id,))
for row in cur.fetchall():
    indent = "  " * row[0]
    print(f"{indent}[{row[0]}] {row[1]}({', '.join(row[2] or [])}) "
          f"raw={row[3]:.4f} effective={row[4]:.4f} rule={row[5]}")

# ── truth_status() ────────────────────────────────────────────
# Returns 'supported' | 'insufficient' | 'contradicted' | 'unknown' [Fix 20].
# 'unknown' = open-world: no claim made. 'insufficient' = claims exist but
# are weak and UNOPPOSED. 'contradicted' = actively opposed (open conflicts).
cur.execute("""
    SELECT truth_status(%s, ARRAY[%s::uuid, %s::uuid], %s, NULL, 0.5)
""", (
    stable_uuid('is_a',         'predicate'),
    stable_uuid('ada_lovelace', 'entity'),
    stable_uuid('person',       'entity'),
    stable_uuid('reality',      'context'),
))
print(f"truth_status: {cur.fetchone()[0]}")   # 'supported'

# ── validate_kb_integrity() ───────────────────────────────────
# Run after bulk ingestion alongside detect_conflicts().
cur.execute("""
    SELECT check_name, violation_count, detail
    FROM validate_kb_integrity(%s, false)
    ORDER BY violation_count DESC
""", (stable_uuid('reality', 'context'),))
for row in cur.fetchall():
    print(f"[{row[0]}] violations={row[1]}: {row[2]}")

# ── detect_conflicts() ────────────────────────────────────────
cur.execute(
    "SELECT detect_conflicts(%s) AS new_conflicts",
    (stable_uuid('reality', 'context'),)
)
print(f"New conflicts detected: {cur.fetchone()[0]}")
conn.commit()

# ── Inspect conflicts with severity ──────────────────────────
cur.execute("""
    SELECT cf.conflict_kind, cf.severity,
           seba.credibility_adjusted, seba.effective_mean, seba.raw_mean
    FROM conflicts cf
    JOIN statement_effective_belief seba ON seba.id = cf.statement_a
    WHERE cf.resolved = false
    ORDER BY cf.severity DESC NULLS LAST
    LIMIT 10
""")
for row in cur.fetchall():
    print(f"kind={row[0]} severity={row[1]:.4f} "
          f"cred_adj={row[2]:.4f} effective={row[3]:.4f} raw={row[4]:.4f}")

# ── compute_derived_belief() ─────────────────────────────────
# Combines the PREMISES of one rule application [Fix 14].
# Modes: 'min' (default; correlated premises) | 'noisy_and'
# (independent premises). 'log_odds' raises — premise conjunction can
# never exceed the weakest premise; see combine_evidence() below.
# Raises if any parent has statement_kind='statistical'.
cur.execute("""
    SELECT out_alpha, out_beta
    FROM compute_derived_belief(%s, %s, %s)
""", (
    [parent_id_1, parent_id_2],  # premises of ONE rule application
    1,                           # chain length
    'min',                       # or 'noisy_and' for independent premises
))
alpha, beta = cur.fetchone()
mean = alpha / (alpha + beta)
print(f"Derived belief: alpha={alpha:.4f}, beta={beta:.4f}, mean={mean:.4f}")

# ── combine_evidence() [Fix 14] ──────────────────────────────
# Merges multiple INDEPENDENT DERIVATIONS of the SAME conclusion
# (log-odds accumulation — the v0.8 'log_odds' semantics, in the place
# where they are actually correct). Only pass derivations that do not
# share ancestor premises (check via why()), or shared evidence is
# double-counted.
cur.execute("""
    SELECT out_alpha, out_beta FROM combine_evidence(%s)
""", ([derivation_result_1, derivation_result_2],))

# ── update_belief() with p_override ─────────────────────────
# Empirical statements: p_override=False (default).
# Ontological statements: p_override=True required (deliberate correction).
cur.execute("SELECT update_belief(%s, %s, %s, %s)",
            (statement_id, 0.90, True, False))   # empirical, no override needed
conn.commit()

# ── update_trust() ───────────────────────────────────────────
cur.execute(
    "SELECT update_trust(%s, %s, %s, %s, %s)",
    (
        stable_uuid('wikidata',       'source'),
        stable_uuid('domain_history', 'context'),
        True,   # correct
        1.0,    # weight
        False,  # p_override: not protected
    )
)
conn.commit()
*/