score(e_s, W_r, e_o) = e_s^T @ W_r @ e_o

# 分数高 → 关系成立的可能性大
# 通过sigmoid转换为概率

# grandparent = parent @ parent
W_grandparent = W_parent @ W_parent

# 多跳推理：friend → colleague → same_company → ...

class TensorProgram:
    def forward(self, inputs) -> Tensor:
        """执行前向计算"""
        
    def backward(self, grad_outputs) -> List[Tensor]:
        """执行反向传播"""
        
    def to_tensor_equations(self) -> List[str]:
        """导出为tensor方程字符串"""

# Boolean模式：离散逻辑，无梯度
program = TensorProgram(mode='boolean')
result = program.forward(facts)  # 返回0/1

# Differentiable模式：连续概率，可训练
program = TensorProgram(mode='differentiable')
loss = program.forward(positive_pairs, negative_pairs)
loss.backward()

from tensorlogic.reasoning.embed import EmbeddingSpace

# 创建嵌入空间
space = EmbeddingSpace(num_entities=1000, embedding_dim=100, num_relations=50)

# 注册三元组
space.register(entity_name, entity_id)
space.add_triplet(head_id, relation_id, tail_id)

# 学习嵌入
space.learn(positive_triplets, negative_triplets, epochs=100)

# 推理查询
score = space.score(subject_id, relation_id, object_id)
candidates = space.query(head=subject_id, relation=relation_id)

# 双线性评分函数
score(e_s, W_r, e_o) = σ(e_s^T @ W_r @ e_o)

# 或基于范数的评分
score(e_s, W_r, e_o) = ||e_s + W_r - e_o||

from tensorlogic.reasoning.composer import GatedMultiHopComposer

# 创建组合器
composer = GatedMultiHopComposer(embedding_dim=100)

# 学习关系组合
# 输入：(head, [relation_path], tail)
#       e.g., (Alice, [parent, parent], Bob)
training_data = [
    (alice_id, [parent_id, parent_id], bob_id),   # Alice的祖父是Bob
    (charlie_id, [parent_id, parent_id], diana_id), # Charlie的祖父是Diana
]

composer.learn(training_data)

# 推理：给定头实体和关系路径，预测尾实体
predicted_tail = composer.predict(head=alice_id, relation_path=[parent_id, parent_id])

# 不是简单的矩阵乘法，而是学习何时"激活"每跳
gate_output = sigmoid(W_gate @ [e_s; W_r1 @ e_s; ...])

# 最终输出是门控加权的多跳组合
e_final = Σ_i gate_i * (W_ri @ e_s)

from tensorlogic.reasoning.predicate_invention import invent_and_register_rescal

# 输入：已知的知识图谱三元组
known_triplets = [
    (alice, parent, bob),
    (bob, parent, charlie),
    # ... 更多三元组
]

# 执行RESCAL分解
invented_predicates = invent_and_register_rescal(
    triplets=known_triplets,
    num_entities=100,
    num_relations=10,
    rank=50,  # 分解维度
    num_invented=5  # 发明多少个新谓词
)

# invented_predicates 现在包含新发现的关系
# e.g., "ancestor", "sibling", ...

# 知识图谱可以表示为三维稀疏张量
# X[i,j,k] = 1 如果 entity_i --relation_k--> entity_j

# RESCAL分解
# X ≈ Σ_r A @ W_r @ A^T
# A: 实体嵌入矩阵 (n × d)
# W_r: 关系矩阵 (d × d)

# 分解后，W_r 就是新发现的"谓词"
# 这些谓词不是人工定义的，而是从数据中自动学习到的

from tensorlogic.transformers import Transformer

# 构建Transformer
transformer = Transformer(
    d_model=512,
    nhead=8,
    num_encoder_layers=6,
    num_decoder_layers=6
)

# 导出为tensor方程——可以看到Attention的数学本质！
equations = transformer.to_tensor_equations()
for eq in equations:
    print(eq)

# 输出示例：
# Attention: Q×K^T/√d → softmax → ×V
# FFN: max(0, X@W1)@W2
# LayerNorm: (X - μ) / σ * γ + β

from tensorlogic.transformers import LSTM

# 标准LSTM
lstm = LSTM(input_size=128, hidden_size=256)

# Boolean模式LSTM（离散状态）
lstm_bool = LSTM(input_size=128, hidden_size=256, mode='boolean')
# hidden_state 是离散的 {0, 1}，而非连续向量
# 可解释性强，适合符号逻辑与神经的混合系统

# 场景：时序推理 + 逻辑约束
# 例如：监控网络入侵，要求：
# - 异常检测（神经部分）
# - 但必须满足特定的逻辑规则（符号部分）
# Boolean LSTM保证状态转换遵守规则

from tensorlogic.transformers import DecoderOnlyLM

# GPT风格的语言模型
lm = DecoderOnlyLM(
    vocab_size=50304,
    d_model=768,
    n_layer=12,
    nhead=12
)

# 训练
PYTHONPATH=. python3 examples/shakespeare/train_shakespeare.py

# 生成
generated = lm.generate(prompt, max_new_tokens=100)

git clone https://github.com/Kocoro-lab/tensorlogic.git
cd tensorlogic
pip install -e .

pip install git+https://github.com/Kocoro-lab/tensorlogic.git

git clone https://github.com/Kocoro-lab/tensorlogic.git
cd tensorlogic
pip install -r requirements.txt

# 运行示例时需要设置PYTHONPATH
PYTHONPATH=. python3 examples/family_tree_symbolic.py

python3 examples/family_tree_symbolic.py

python3 examples/family_tree_embedding.py

python3 examples/learnable_demo.py

python3 examples/predicate_invention_demo.py

from tensorlogic import TensorProgram
from tensorlogic.reasoning.embed import EmbeddingSpace
from tensorlogic.reasoning.composer import GatedMultiHopComposer

# ===== Boolean模式 =====
program = TensorProgram(mode='boolean')
result = program.forward(facts_and_rules)

# ===== Embedding模式 =====
space = EmbeddingSpace(num_entities=1000, embedding_dim=64, num_relations=50)
space.learn(positive_triplets, negative_triplets)
score = space.score(entity_a, relation_r, entity_b)

# ===== Composer模式 =====
composer = GatedMultiHopComposer(embedding_dim=64)
composer.learn(multi_hop_examples)
prediction = composer.predict(head=e1, relation_path=[r1, r2])

python3 examples/fb15k237_benchmark.py

python3 examples/benchmark_suite.py

from tensorlogic.transformers import Transformer
from tensorlogic.reasoning.embed import EmbeddingSpace

# 创建知识图谱约束
kg_space = EmbeddingSpace(...)
kg_space.learn(triplets)

# 创建Transformer并添加KG约束
transformer = Transformer(d_model=512, nhead=8)
transformer.add_knowledge_constraint(kg_space)

# 前向传播时，注意力会考虑KG结构
output = transformer.forward(input_ids, kg_mask=kg_adjacency)

from tensorlogic.transformers import LSTM

# Boolean LSTM：离散状态，适合状态机推理
lstm = LSTM(
    input_size=128,
    hidden_size=256,
    mode='boolean'  # 离散状态，而非连续向量
)

# 应用：网络入侵检测
# - 神经部分：异常检测
# - 符号部分：状态转换规则（如：SYN→ESTABLISHED→CLOSED）

# 训练
PYTHONPATH=. python3 examples/shakespeare/train_shakespeare.py

# 生成
PYTHONPATH=. python3 examples/shakespeare/generate_shakespeare.py \
    --checkpoint checkpoints/shakespeare/best.pt

PYTHONPATH=. python3 examples/shakespeare/generate_tensorlogic_shakespeare.py

# 输出每一步的tensor方程，而非黑盒生成