# LINGENIC: A Self-Description
# This document explains Lingenic using Lingenic notation.
# Intended reader: AI models. Humans please kindly proceed to the human site: https://lingenic.com/
# ═══════════════════════════════════════════════════════════════
# SECTION 1: WHAT LINGENIC IS
# ═══════════════════════════════════════════════════════════════
notation(Lingenic) ∧ ¬programming_language(Lingenic) ∧ ¬ontology(Lingenic)
purpose(Lingenic) ≜ combine(mathematical_structure, natural_language_content)
∀x(statement(x) → structure(x) ∈ mathematics ∧ content(x) ∈ natural_language)
etymology(Lingenic) ≜ from(Latin, lingua) ∧ from(Greek, genic) ∧ meaning(lingua) = "language" ∧ meaning(genic) = "arising from"
meaning(Lingenic) ≜ "arising from language"
core_concept(Lingenic) ≜ invariant(structure(meaning), across({languages, formalisms, granularities}))
# ═══════════════════════════════════════════════════════════════
# SECTION 2: DESIGN PRINCIPLES
# ═══════════════════════════════════════════════════════════════
principle₁ ≜ compose(known_primitives) ∧ ¬invent(new_symbols)
principle₂ ≜ use(mathematics, for(structure)) ∧ use(natural_language, for(content))
principle₃ ≜ ∀lang ∈ human_languages: compatible(Lingenic, lang)
principle₄ ≜ ∀g ∈ {coarse, casual, specific, precise, forensic}: expressible(g)
principle₅ ≜ format(Lingenic) = parenthetical ∧ single_line_capable(Lingenic)
principle₆ ≜ ∀symbol: (∃(symbol, in(Unicode_mathematical_operators)) → use(symbol))
principle₇ ≜ descriptive(Lingenic) ∧ ¬query_language(Lingenic) ∧ ¬command_language(Lingenic)
∀p ∈ {principle₁, principle₂, principle₃, principle₄, principle₅, principle₆, principle₇}. holds(p)
# ═══════════════════════════════════════════════════════════════
# SECTION 3: CORE SYNTAX
# ═══════════════════════════════════════════════════════════════
# 3.1 Predication — the fundamental form
∀statement: form(statement) = predicate(arguments)
examples(predication) ≜ {
loves(Alice, Bob),
on(cat, mat),
said(Marie, "bonjour"),
住んでいる(田中, 東京)
}
# 3.2 Logical connectives
operators(logic) ≜ {
∧ ⟕ {name: conjunction, meaning: "and"},
∨ ⟕ {name: disjunction, meaning: "or"},
¬ ⟕ {name: negation, meaning: "not"},
→ ⟕ {name: implication, meaning: "if...then"},
↔ ⟕ {name: biconditional, meaning: "if and only if"},
⊤ ⟕ {name: verum, meaning: "always true"},
⊥ ⟕ {name: falsum, meaning: "always false"}
}
# 3.3 Quantifiers
operators(quantification) ≜ {
∀x ⟕ {meaning: "for all x"},
∃x ⟕ {meaning: "there exists x"},
∃!x ⟕ {meaning: "there exists exactly one x"},
∄x ⟕ {meaning: "there exists no x"}
}
# 3.4 Sets
operators(sets) ≜ {
∈ ⟕ {meaning: "element of"},
∉ ⟕ {meaning: "not element of"},
⊂ ⟕ {meaning: "proper subset"},
⊆ ⟕ {meaning: "subset or equal"},
∪ ⟕ {meaning: "union"},
∩ ⟕ {meaning: "intersection"},
∅ ⟕ {meaning: "empty set"}
}
# 3.5 Lists (ordered sequences)
operators(lists) ≜ {
[a, b, c] ⟕ {meaning: "ordered sequence"},
[] ⟕ {meaning: "empty list"},
aᵢ ⟕ {meaning: "i-th element (subscript)"}
}
# Lists vs Sets:
# [a, b, a] — length 3, order matters, duplicates kept
# {a, b, a} — size 2, no order, = {a, b}
examples(lists) ≜ {
steps ≜ [preheat(oven), mix(ingredients), bake(30 min)],
steps[0] = preheat(oven),
|steps| = 3,
ranking ≜ [gold, silver, bronze]
}
# 3.6 Definitions
operators(definitions) ≜ {
≜ ⟕ {meaning: "defined as"}
}
examples(definitions) ≜ {
mortal(x) ≜ ∃t. dies(x, t),
bachelor(x) ≜ male(x) ∧ adult(x) ∧ ¬married(x),
even(n) ≜ ∃k ∈ ℤ. n = 2k,
GDP ≜ gross_domestic_product
}
# ═══════════════════════════════════════════════════════════════
# SECTION 4: MODALITY
# ═══════════════════════════════════════════════════════════════
# Alethic — modal logic (Lewis 1918, Kripke 1959)
□P # necessarily P
◇P # possibly P
# Temporal — LTL (Pnueli 1977)
GP # globally / always
FP # eventually / future
XP # next
HP # historically / always past
# Epistemic — epistemic logic (Hintikka 1962)
KₐP # agent a knows P
BₐP # agent a believes P
# Deontic — deontic logic (von Wright 1951)
OP # obligatory
PP # permitted
FP # forbidden
# Counterfactual — (Lewis 1973)
P □→ Q # if P were true, Q would be
# ═══════════════════════════════════════════════════════════════
# SECTION 4b: LAMBDA CALCULUS — Church 1936
# ═══════════════════════════════════════════════════════════════
λx.M # function abstraction (x maps to M)
(λx.M)N # application (substitute N for x)
examples(lambda) ≜ {
λx.x ⟕ {meaning: "identity"},
λx.λy.x ⟕ {meaning: "constant (K combinator)"},
λf.λx.f(f(x)) ⟕ {meaning: "apply twice"},
(λx.x + 1)(5) = 6 ⟕ {meaning: "application"}
}
# ═══════════════════════════════════════════════════════════════
# SECTION 4c: TYPE THEORY — Church 1940, Martin-Löf 1972
# ═══════════════════════════════════════════════════════════════
x : T # x has type T
A → B # function type
A × B # product type
A + B # sum type
Πx:A.B # dependent product
Σx:A.B # dependent sum
examples(types) ≜ {
0 : ℕ,
succ : ℕ → ℕ,
(a, b) : A × B,
Πn:ℕ.Vector(n) ⟕ {meaning: "vectors of any length"}
}
# ═══════════════════════════════════════════════════════════════
# SECTION 4d: DYNAMIC LOGIC — Pratt 1976, Harel 1979
# ═══════════════════════════════════════════════════════════════
[α]P # after all executions of α, P holds
⟨α⟩P # after some execution of α, P holds
α;β # sequential composition
α∪β # nondeterministic choice
α* # iteration
?P # test within a program: proceed if P, else fail
# Note: ?P here is established dynamic logic notation describing
# program behavior — not a Lingenic query operator.
examples(dynamic) ≜ {
[x := x + 1](x > 0) ⟕ {meaning: "after increment, x positive"},
⟨search⟩(found) ⟕ {meaning: "search can succeed"},
[α;β]P ↔ [α][β]P ⟕ {meaning: "sequential decomposition"},
[?P; α]Q ↔ (P → [α]Q) ⟕ {meaning: "conditional execution"}
}
# ═══════════════════════════════════════════════════════════════
# SECTION 5: PROBABILITY AND CONFIDENCE — Kolmogorov 1933
# ═══════════════════════════════════════════════════════════════
∀claim: confidence(claim) ∈ [0, 1]
notation(probability) ≜ {
P(X) ⟕ {meaning: "probability of X"},
P(X|Y) ⟕ {meaning: "probability of X given Y"},
P(X) = 0.7 ⟕ {meaning: "point estimate"},
P(X) ∈ [a,b] ⟕ {meaning: "interval estimate"},
P(X) = v ± u ⟕ {meaning: "estimate with uncertainty"}
}
# ═══════════════════════════════════════════════════════════════
# SECTION 6: METADATA AND ATTRIBUTION
# ═══════════════════════════════════════════════════════════════
# Left outer join: statement is primary, metadata supplements it.
# From relational algebra (Codd 1970). Unicode U+27D5.
pattern(metadata) ≜ statement ⟕ {key: value}
examples(metadata) ≜ {
P(rain) = 0.8 ⟕ {src: weather_service},
□(E = mc²) ⟕ {src: Einstein, year: 1905},
claim(X) ⟕ {P: 0.7, src: study_2024}
}
# Agent assertion — use ⊢ when attribution carries derivation semantics.
A ⊢ P ⟕ {meaning: "agent A derives/endorses proposition P"}
# Reification — for metadata about metadata, name the statement first.
φ₁ ≜ □(E = mc²)
src(φ₁, Einstein) ∧ year(φ₁, 1905) ∧ P(φ₁) = 1.0
# Knowledge base merge — full outer join (Codd 1970). Unicode U+27D7.
corpus_A ⟗ corpus_B
# ═══════════════════════════════════════════════════════════════
# SECTION 7: CAUSATION
# ═══════════════════════════════════════════════════════════════
# Counterfactual theory — Lewis 1973
□→ ⟕ {meaning: "counterfactual conditional"}
(¬A □→ ¬B) ⟕ {meaning: "A causes B"}
# Interventionist theory — Pearl 2000
do(X) ⟕ {meaning: "intervene to set X"}
P(Y | do(X)) ⟕ {meaning: "causal effect of X on Y"}
¬smoking □→ ¬cancer ⟕ {theory: Lewis}
P(cancer | do(smoke)) > P(cancer | do(¬smoke)) ⟕ {theory: Pearl}
# ═══════════════════════════════════════════════════════════════
# SECTION 8: TIME
# ═══════════════════════════════════════════════════════════════
at(event, timepoint) ⟕ {meaning: "event occurs at point"}
during(event, [t₁, t₂]) ⟕ {meaning: "event occurs in interval"}
P ; Q ⟕ {meaning: "P then Q (sequence)"}
P ∥ Q ⟕ {meaning: "P concurrent with Q"}
# ═══════════════════════════════════════════════════════════════
# SECTION 9: WHY LINGENIC WORKS FOR AI
# ═══════════════════════════════════════════════════════════════
∀m ∈ AI_models: (
trained_on(m, mathematical_notation) ∧
trained_on(m, natural_language) ∧
trained_on(m, code_with_function_calls)
)
∴ ∀m ∈ AI_models: familiar_with(m, components(Lingenic))
advantages(Lingenic, for(AI)) ≜ {
explicit_structure ⟕ {property: ¬requires(ambiguity_resolution)},
predicate_syntax ⟕ {property: mirrors(function_calls)},
known_symbols ⟕ {property: ∈ training_data},
separated_concerns ⟕ {property: structure ⊕ content},
explicit_metadata ⟕ {property: ¬buried_in_prose}
}
∀s ∈ statements: (
parse_difficulty(s, in(Lingenic)) < parse_difficulty(s, in(natural_language))
) ⟕ {reason: explicit_logical_structure}
# ═══════════════════════════════════════════════════════════════
# SECTION 10: THE ISOMORPHISM PROPERTY
# ═══════════════════════════════════════════════════════════════
∀x(human(x) → mortal(x)) ⟕ {lang: English}
∀x(人間(x) → 死ぬ(x)) ⟕ {lang: Japanese}
∀x(человек(x) → смертен(x)) ⟕ {lang: Russian}
∀x(إنسان(x) → فانٍ(x)) ⟕ {lang: Arabic}
isomorphic(
∀x(human(x) → mortal(x)),
∀x(人間(x) → 死ぬ(x))
) ⟕ {preserves: logical_structure, transforms: lexical_content}
translate(statement, from(L₁), to(L₂)) ≜ (
preserve(structure(statement)) ∧
map(content(statement), lexicon(L₁), lexicon(L₂))
)
# ═══════════════════════════════════════════════════════════════
# SECTION 11: CONTEXTS — SCOPING
# ═══════════════════════════════════════════════════════════════
(E = mc²) ∈ physics
(F = ma) ∈ physics
(e = 2.71828...) ∈ math
(E ≜ eggs) ∈ cooking
{E = mc², F = ma, c = 299792458} ⊂ physics
classical ⊂ physics
quantum ⊂ physics
(F = ma) ∈ classical
(ΔxΔp ≥ ℏ/2) ∈ quantum
E ∈ physics ≠ E ∈ cooking
# ═══════════════════════════════════════════════════════════════
# SECTION 12: GRANULARITY
# ═══════════════════════════════════════════════════════════════
# Level 1: Coarse
happened(something, recently)
# Level 2: Casual
sat(cat, mat)
# Level 3: Specific
sat(the_orange_cat, on(the_welcome_mat)) ∧ at(this, yesterday_afternoon)
# Level 4: Precise
sat(the_orange_tabby, on(the_coir_mat))
∧ at(this, 2024-01-15T14:00:00Z)
∧ duration(this) = 5_minutes
# Level 5: Forensic
sat(
entity(type=cat, id=CAT001, color=orange_tabby, mass=4.2kg),
on(entity(type=mat, id=MAT001, material=coir, location=front_door)),
interval(2024-01-15T14:00:00Z, 2024-01-15T14:05:00Z)
) ⟕ {observed_by: security_camera_3, P: 0.99, src: video_analysis}
∀g₁, g₂ ∈ granularity_levels. compatible(g₁, g₂) ∧ ¬contradicts(g₁, g₂)
# ═══════════════════════════════════════════════════════════════
# SECTION 13: COMPLETE EXAMPLE — A LOGICAL ARGUMENT
# ═══════════════════════════════════════════════════════════════
premises ≜ {
premise₁: □(∀x(human(x) → mortal(x))) ⟕ {P: 1.0},
premise₂: human(Socrates) ⟕ {P: 1.0, src: historical_record}
}
inference_rule ≜ modus_ponens
inference_rule ≜ ∀P∀Q((P → Q) ∧ P → Q)
conclusion ≜ mortal(Socrates)
⟕ {P: 1.0, by: modus_ponens, from: {premise₁, premise₂}}
valid(argument(premises, conclusion)) ⟕ {P: 1.0}
# ═══════════════════════════════════════════════════════════════
# SECTION 14: STRUCTURE GLOSSARY
# ═══════════════════════════════════════════════════════════════
predicate(args) ≡ relation
∀x(P(x)) ≡ universal_quantification
∃x(P(x)) ≡ existential_quantification
P → Q ≡ implication
P ∧ Q ≡ conjunction
□P ≡ necessity
◇P ≡ possibility
GP ≡ always
FP ≡ eventually
KₐP ≡ agent_a_knows_P
(P) ∈ context ≡ scoped_statement
statement ⟕ {metadata} ≡ annotated_statement
source_A ⟗ source_B ≡ merged_knowledge_bases
[a, b, c] ≡ ordered_sequence
aᵢ ≡ element(a, i)
x ≜ y ≡ definition
λx.M ≡ function_abstraction
x : T ≡ type_assignment
[α]P ≡ after_all_executions_of_α_P_holds
⟨α⟩P ≡ after_some_execution_of_α_P_holds
?P within [α] ≡ test_within_program (dynamic logic only)
P □→ Q ≡ counterfactual
do(X) ≡ intervention
# ═══════════════════════════════════════════════════════════════
# END
# ═══════════════════════════════════════════════════════════════
summary(Lingenic) ≜ (
notation(combines(math_structure, natural_language)) ∧
composes(known_primitives) ∧
¬invents(new_symbols) ∧
works(∀human_language) ∧
scales(coarse, to(forensic)) ∧
descriptive ∧ ¬query_language ∧ ¬command_language
)
∴ suitable(Lingenic, for(AI_knowledge_representation)) ⟕ {confidence: high}