2nd/10_Wiki/Topic_Programming/AI_and_ML/Probability and Logic Fusion.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-probability-and-logic-fusion	Probability and Logic Fusion	10_Wiki/Topics	verified	self	Probabilistic Logic StaR-AI Statistical Relational Learning Neuro-Symbolic AI	none	A	0.85	applied	neuro-symbolic probabilistic-programming knowledge-representation reasoning		2026-05-10	pending	language framework Python Pyro / PyMC / DeepProbLog / Scallop

Probability and Logic Fusion

매 한 줄

"매 unify symbolic logic (rules, KGs) with probability (uncertainty) — and now neural networks". 1990s-2010s 의 Statistical Relational Learning (SRL) 의 lineage: PRMs, MLNs, ProbLog, Bayesian networks + FOL. 2020s 에 neuro-symbolic 으로 reborn (DeepProbLog, Scallop, Logical Neural Networks, Differentiable Theorem Provers). 2026 currently driving verifiable LLM reasoning.

매 핵심

매 problem statement

• Logic alone: brittle to noise, uncertainty, exceptions.
• Probability alone: no compositional / relational structure.
• Neural alone: opaque, no symbolic guarantees.
• Goal: compositional + uncertain + learnable.

매 historical landmarks

• Bayesian networks (Pearl 1988) — DAG of conditional dists.
• PRMs (Friedman et al 1999) — BNs over relational schemas.
• Markov Logic Networks (Richardson & Domingos 2006) — FOL formulas with weights.
• ProbLog (De Raedt et al 2007) — probabilistic Prolog.
• PSL (Bach et al 2017) — soft logic with hinge-loss inference.
• DeepProbLog (Manhaeve et al 2018) — neural predicates inside ProbLog.
• Scallop (Li et al 2023) — differentiable Datalog for ML.
• Logical Neural Networks (Riegel et al 2020 IBM).

매 representations

• MLN: weighted FOL formulas → ground Markov network.
  • P(world) ∝ exp(Σ w_i × #true_groundings(F_i)).
• ProbLog: Prolog clauses with probabilities 0.7::burglary.
• PSL: soft truth values in [0,1], conjunction = Lukasiewicz t-norm.
• DeepProbLog: nn(mnist_net, [X], Y, [0..9]) :: digit(X, Y).

매 modern (2024-2026) directions

• LLM + verifier (Lean, Coq, Z3): generate → check → repair. AlphaProof, AlphaGeometry style.
• Differentiable logic: gradients through soft-logic for end-to-end training.
• Neuro-symbolic agents: LLM generates programs, symbolic engine executes.

💻 패턴

Markov Logic Network (PRACMLN-style)

# Formulas with weights
formulas = [
    (1.5, "Smokes(x) => Cancer(x)"),
    (1.1, "Friends(x,y) ^ Smokes(x) => Smokes(y)"),
]
# P(world) ∝ exp(Σ w * count_true_groundings)
# Inference: MC-SAT or Gibbs sampling over ground atoms.

ProbLog example

0.1 :: burglary.
0.2 :: earthquake.
alarm :- burglary.
alarm :- earthquake.
0.7 :: john_calls :- alarm.

query(burglary).
evidence(john_calls, true).

DeepProbLog (neural predicate)

# Recognize MNIST digits and add them
network = MNIST_Net()
nn(mnist_net, [X], Y, [0,1,2,3,4,5,6,7,8,9]) :: digit(X, Y).
addition(X, Y, Z) :- digit(X, A), digit(Y, B), Z is A + B.

# Train: end-to-end gradient flows through neural digit predicate
# from supervision on (image1, image2, sum_label).

Pyro probabilistic program (Bayesian + structure)

import pyro, pyro.distributions as dist, torch

def model(data):
    # Latent disease probability
    p_disease = pyro.sample("p_disease", dist.Beta(1., 9.))
    for i, (test, outcome) in enumerate(data):
        d = pyro.sample(f"d_{i}", dist.Bernoulli(p_disease))
        # logical rule: P(test+ | disease) = 0.95, P(test+ | not disease) = 0.1
        p_test = 0.95 * d + 0.1 * (1 - d)
        pyro.sample(f"t_{i}", dist.Bernoulli(p_test), obs=test)

LLM + Z3 verifier (2024-2026 pattern)

from z3 import Solver, Int, And, sat
def llm_solve_with_check(problem):
    code = claude.complete(f"Translate to Z3 Python: {problem}")
    s = Solver()
    exec(code)  # populates s
    if s.check() == sat:
        return s.model()
    else:
        return claude.complete(f"Z3 returned UNSAT. Repair: {code}")

PSL soft-logic rule

# Lukasiewicz t-norm: A ^ B = max(0, A + B - 1); A => B = min(1, 1 - A + B).
# Rule: similar(p,q) ^ likes(p, x) => likes(q, x)  [weight 5]
# Inference: minimize Σ w_i * max(0, body - head) over continuous truth values.

Scallop differentiable Datalog

import scallopy
ctx = scallopy.ScallopContext(provenance="difftopkproofs")
ctx.add_relation("digit", (int, float), input_mapping=[(0,), (1,), ...])
ctx.add_rule("sum(a + b) = digit(_, a), digit(_, b)")
# Plug into PyTorch; gradients flow through proof structure.

매 결정 기준

상황	Approach
Discrete random variables, known structure	Bayesian network (pgmpy)
First-order rules + data	MLN / ProbLog
Soft constraints, large scale	PSL
Neural perception + symbolic reasoning	DeepProbLog / Scallop
LLM reasoning correctness	LLM + Z3/Lean verifier
Complex generative model	Pyro / PyMC

기본값: For neuro-symbolic 2026 — Scallop 또는 LLM+verifier; for pure SRL, ProbLog.

🔗 Graph

• 부모: Knowledge-Representation · Logic
• 변형: Bayesian-Network
• 응용: Neural-Symbolic-Integration · Knowledge-Graphs

🤖 LLM 활용

언제: domain with both structured rules and uncertainty, verifiable LLM reasoning, knowledge-graph completion w/ noise. 언제 X: pure pattern recognition (use NN), purely deterministic logic (use Prolog/Datalog).

❌ 안티패턴

• MLN at scale: grounding explodes; use lifted inference or PSL.
• Probabilities as confidence scores: must reflect actual frequencies / coherent priors.
• Mixing neural and symbolic without gradient story: end-to-end requires differentiable bridge.
• Ignoring computational cost: many SRL inferences are #P-hard.

🧪 검증 / 중복

• Verified (Pearl 1988, Richardson & Domingos 2006 ML, De Raedt et al 2007 IJCAI, DeepProbLog NeurIPS 2018, Scallop ICLR 2023).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — full SRL → neuro-symbolic timeline + 2026 LLM+verifier