gsn-model-parser 0.16.10__py3-none-any.whl

gsn_model_parser/__init__.py

@@ -0,0 +1,5 @@
+"""Parse Goal Structuring Notation (.gsn) models."""
+
+from gsn_model_parser.parser import GSNModel, GSNNode, get_gsn_nodes, list_solutions, load_model
+
+__all__ = ['GSNModel', 'GSNNode', 'get_gsn_nodes', 'list_solutions', 'load_model']

gsn_model_parser/__main__.py

@@ -0,0 +1,3 @@
+from gsn_model_parser.parser import main
+
+main()

gsn_model_parser/gsn.tx

@@ -0,0 +1,218 @@
+AssuranceModel:
+    assurancemodels += GSNDefinition*
+;
+
+GSNDefinition:
+    Goals|Strategies|Contexts|Assumptions|Justifications|Solutions
+;
+
+Goals:
+    'GOALS' name=ID '{' goals *= GoalNode '}'
+;
+
+Strategies:
+    'STRATEGIES' name=ID '{' strategies *= StrategyNode '}'
+;
+
+Contexts:
+    'CONTEXTS' name=ID '{' contexts *= ContextNode '}'
+;
+
+Assumptions:
+    'ASSUMPTIONS' name=ID '{' assumptions *= AssumptionNode '}'
+;
+
+Justifications:
+    'JUSTIFICATIONS' name=ID '{' justifications *= JustificationNode '}'
+;
+
+Solutions:
+    'SOLUTIONS' name=ID '{' solutions *= SolutionNode '}'
+;
+
+GoalSupportNodes:
+    GoalNode
+    | StrategyNode
+    | SolutionNode
+    | GoalNodeRef
+    | StrategyNodeRef
+    | SolutionNodeRef
+;
+
+StrategySupportNodes:
+    GoalNode
+    | StrategyNode
+    | GoalNodeRef
+    | StrategyNodeRef
+;
+
+ContextNodes:
+    ContextNode
+    | ContextNodeRef
+;
+
+AssumptionNodes:
+    AssumptionNode
+    | AssumptionNodeRef
+;
+
+JustificationNodes:
+    JustificationNode
+    | JustificationNodeRef
+;
+
+ALLNodes:
+    GoalNode
+    | StrategyNode
+    | SolutionNode
+    | ContextNode
+    | AssumptionNode
+    | JustificationNode
+;
+
+GoalNodeRef:
+    'ref_goal' ref=[GoalNode:FQN]
+;
+
+StrategyNodeRef:
+    'ref_strategy' ref=[StrategyNode:FQN]
+;
+
+SolutionNodeRef:
+    'ref_solution' ref=[SolutionNode:FQN]
+;
+
+ContextNodeRef:
+    'ref_context' ref=[ContextNode:FQN]
+;
+
+AssumptionNodeRef:
+    'ref_assumption' ref=[AssumptionNode:FQN]
+;
+
+JustificationNodeRef:
+    'ref_justification' ref=[JustificationNode:FQN]
+;
+
+Number:
+    FLOAT | INT
+;
+
+Opinion:
+    '(' b=Number ',' d=Number ',' u=Number (',' a=Number)? ')'
+;
+
+WarrantBlock:
+    'warrant' '{'
+        ('givenTrue' givenTrue=Opinion)?
+        ('givenFalse' givenFalse=Opinion)?
+    '}'
+;
+
+GoalChild:
+    GoalSupportNodes | ContextNodes | AssumptionNodes | JustificationNodes
+;
+
+StrategyChild:
+    StrategySupportNodes | ContextNodes | AssumptionNodes | JustificationNodes
+;
+
+GoalDetails:
+    child=GoalChild
+    (warrants=WarrantBlock)?
+;
+
+StrategyDetails:
+    child=StrategyChild
+    (warrants=WarrantBlock)?
+;
+
+GoalNode:
+    'goal' name=ID '{'
+        (details=BaseNode)?
+        ('status' status=SolutionStatus)?
+        (nodedetails *= GoalDetails)
+    '}'
+;
+
+StrategyNode:
+    'strategy' name=ID '{'
+        (details=BaseNode)?
+        ('argument' argumentType=ArgumentType)?
+        (nodedetails *= StrategyDetails)
+    '}'
+;
+
+ContextNode:
+    'context' name=ID '{'
+        (details=BaseNode)?
+    '}'
+;
+
+AssumptionNode:
+    'assumption' name=ID '{'
+        (details=BaseNode)?
+        ('opinion' opinion=Opinion)?
+    '}'
+;
+
+JustificationNode:
+    'justification' name=ID '{'
+        (details=BaseNode)?
+    '}'
+;
+
+SolutionNode:
+    'solution' name=ID '{'
+        (details=BaseNode)?
+        ('status' status=SolutionStatus)?
+        ('opinion' opinion=Opinion)?
+    '}'
+;
+
+BaseNode:
+    (uuid=UUIDType)?
+    (summary=Summary)?
+    (info=Description)?
+    (labels *= LabelInfo)
+    (artifacts *= URI)
+;
+
+SolutionStatus:
+    'NotReviewed' | 'Approved' | 'Disapproved'
+;
+
+ArgumentType:
+    'CONJUNCTION' | 'DISJUNCTION' | 'FUSION' | 'DISCOUNT'
+;
+
+UUIDType:
+    'uuid' info=GUID
+;
+
+Summary:
+    'summary' info=MLString
+;
+
+Description:
+    'info' info=MLString
+;
+
+LabelInfo:
+    'label' name=ID
+;
+
+URI:
+    'artifact' uri=MLString
+;
+
+FQN:
+    ID+['.']
+;
+
+MLString: data=/(?ms)\"(.*?)\"/;
+GUID: /\{?[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\}?/;
+
+Comment:
+  /\/\/.*$/
+;

gsn_model_parser/opinion.py

@@ -0,0 +1,369 @@
+"""Binomial subjective logic opinions and GSN confidence propagation.
+
+Names follow Herd et al., "Towards a compositional semantics for quantitative
+confidence assessment in assurance arguments" (arXiv:2605.22213). The
+operators match eSLIM++ (eslimpp) Opinion2d.
+
+A stored opinion from the parser is a dict with ``b``, ``d``, ``u`` and
+optional ``a``. Propagation always returns an :class:`Opinion`, which
+:meth:`Opinion.as_dict` writes back in that shape.
+"""
+import math
+import sys
+from dataclasses import dataclass
+
+
+# Match eSLIM++ EPS_v for double.
+EPS = sys.float_info.epsilon
+
+
+@dataclass(frozen=True)
+class Opinion:
+    """Binomial opinion ω = (b, d, u, a) with u = 1 − b − d."""
+
+    belief: float
+    disbelief: float
+    uncertainty: float
+    base_rate: float
+
+    def as_dict(self):
+        """Return the parser's ``b``, ``d``, ``u``, ``a`` dict."""
+        return {
+            'b': self.belief,
+            'd': self.disbelief,
+            'u': self.uncertainty,
+            'a': self.base_rate,
+        }
+
+
+def opinion(belief, disbelief, base_rate=0.5):
+    """Build an opinion, deriving uncertainty as ``1 - belief - disbelief``."""
+    return Opinion(belief, disbelief, 1 - belief - disbelief, base_rate)
+
+
+def vacuous(base_rate=0.5):
+    """Opinion with no evidence, ω = (0, 0, 1, a)."""
+    return opinion(0, 0, base_rate)
+
+
+def dogmatic_true(base_rate=0.5):
+    """Certain true opinion, ω = (1, 0, 0, a)."""
+    return opinion(1, 0, base_rate)
+
+
+def dogmatic_false(base_rate=0.5):
+    """Certain false opinion, ω = (0, 1, 0, a)."""
+    return opinion(0, 1, base_rate)
+
+
+# Support-edge warrants that make conditional deduction the identity
+# (conclusion = premise) for base rates in (0, 1).
+# Masses: given true (1, 0, 0), given false (0, 1, 0). Deduction ignores
+# conditional base rates when both uncertainties are 0. If one support
+# warrant is saved, propagation fills the empty one with these opinions.
+# If neither is saved, the child is passed through.
+IDENTITY_GIVEN_TRUE = dogmatic_true(0.5)
+IDENTITY_GIVEN_FALSE = dogmatic_false(0.5)
+
+
+def projected_probability(value):
+    """Projected probability P = b + a·u."""
+    return value.belief + value.base_rate * value.uncertainty
+
+
+def _from_bd(belief, disbelief, base_rate):
+    return Opinion(belief, disbelief, 1 - belief - disbelief, base_rate)
+
+
+def _binom_proj(belief, uncertainty, base_rate):
+    return belief + uncertainty * base_rate
+
+
+def _div(numerator, denominator):
+    """Divide like IEEE JavaScript: 1/0 is inf and 0/0 is nan."""
+    try:
+        return numerator / denominator
+    except ZeroDivisionError:
+        if numerator == 0:
+            return math.nan
+        return math.copysign(math.inf, numerator)
+
+
+def conjunction(left, right):
+    """Conjunction of independent claims (ω_x · ω_y).
+
+    Use when all child claims must hold (divide-and-conquer).
+    """
+    base_x = left.base_rate
+    base_y = right.base_rate
+    factor = (1 - base_x) * base_y * left.belief * right.uncertainty
+    factor += base_x * (1 - base_y) * left.uncertainty * right.belief
+    factor /= 1 - base_x * base_y
+    belief = left.belief * right.belief + factor
+    disbelief = left.disbelief + right.disbelief - left.disbelief * right.disbelief
+    return _from_bd(belief, disbelief, base_x * base_y)
+
+
+def disjunction(left, right):
+    """Disjunction of independent claims (ω_x ⊔ ω_y).
+
+    Use when any one child claim is enough (alternatives).
+    """
+    base_x = left.base_rate
+    base_y = right.base_rate
+    factor = base_x * (1 - base_y) * left.disbelief * right.uncertainty
+    factor += (1 - base_x) * base_y * left.uncertainty * right.disbelief
+    factor /= base_x + base_y - base_x * base_y
+    disbelief = left.disbelief * right.disbelief + factor
+    belief = left.belief + right.belief - left.belief * right.belief
+    return _from_bd(belief, disbelief, base_x + base_y - base_x * base_y)
+
+
+def cumulative_fusion(left, right):
+    """Cumulative fusion ⊕ of independent opinions on the same claim.
+
+    Uncertainty typically shrinks as independent support is added.
+    """
+    uncertainty_x = left.uncertainty
+    uncertainty_y = right.uncertainty
+    mass_denom = uncertainty_x + uncertainty_y - uncertainty_x * uncertainty_y
+
+    if abs(mass_denom) < EPS:
+        belief = (left.belief + right.belief) / 2
+        disbelief = (left.disbelief + right.disbelief) / 2
+    else:
+        belief = (left.belief * uncertainty_y + right.belief * uncertainty_x) / mass_denom
+        disbelief = (left.disbelief * uncertainty_y + right.disbelief * uncertainty_x) / mass_denom
+
+    prior_denom = uncertainty_x + uncertainty_y - 2 * uncertainty_x * uncertainty_y
+    if abs(prior_denom) < EPS:
+        base_rate = (left.base_rate + right.base_rate) / 2
+    else:
+        base_rate = (
+            left.base_rate * uncertainty_y
+            + right.base_rate * uncertainty_x
+            - (left.base_rate + right.base_rate) * uncertainty_x * uncertainty_y
+        ) / prior_denom
+
+    return _from_bd(belief, disbelief, base_rate)
+
+
+def trust_discount(trust, subject):
+    """Trust discounting ⊗: ω = trust ⊗ subject.
+
+    Belief in the source scales the subject's belief and disbelief. Disbelief
+    and uncertainty about the source become uncertainty about the subject.
+    The subject's base rate is kept.
+
+    b = b_trust · b_subject
+    d = b_trust · d_subject
+    u = d_trust + u_trust + b_trust · u_subject
+    a = a_subject
+    """
+    belief = trust.belief * subject.belief
+    disbelief = trust.belief * subject.disbelief
+    return _from_bd(belief, disbelief, subject.base_rate)
+
+
+def conditional_deduction(premise, given_true, given_false):
+    """Conditional deduction ω_y||x = ω_x ⊚ (ω_{y|x}, ω_{y|¬x}).
+
+    Maps a support or context edge: the premise opinion plus the warrants
+    for the premise being true and false.
+    """
+    base_x = premise.base_rate
+
+    # Apex base rate a_y (OpinionNoBase path with EPS guard for masses).
+    apex_nom = base_x * given_true.belief + (1 - base_x) * given_false.belief
+    apex_denom = 1 - (base_x * given_true.uncertainty + (1 - base_x) * given_false.uncertainty)
+    apex_mass = base_x
+    if abs(apex_denom) > EPS:
+        apex_mass = apex_nom / apex_denom
+
+    apex_belief = (
+        base_x * _binom_proj(given_true.belief, given_true.uncertainty, apex_mass)
+        + (1 - base_x) * _binom_proj(given_false.belief, given_false.uncertainty, apex_mass)
+    )
+
+    uncertainty_apex = min(
+        _div(apex_belief - min(given_true.belief, given_false.belief), apex_mass),
+        _div(
+            1 - apex_belief - min(given_true.disbelief, given_false.disbelief),
+            1 - apex_mass,
+        ),
+    )
+
+    uncertainty = uncertainty_apex - (
+        (uncertainty_apex - given_true.uncertainty) * premise.belief
+        + (uncertainty_apex - given_false.uncertainty) * premise.disbelief
+    )
+
+    premise_projection = projected_probability(premise)
+    projection = (
+        _binom_proj(given_true.belief, given_true.uncertainty, apex_mass) * premise_projection
+        + _binom_proj(given_false.belief, given_false.uncertainty, apex_mass)
+        * (1 - premise_projection)
+    )
+
+    belief = projection - apex_mass * uncertainty
+    disbelief = 1 - belief - uncertainty
+
+    # Prior update matches eSLIM++ Opinion::deduction_ (no EPS guard on denom).
+    prior_nom = (
+        premise.base_rate * given_true.belief
+        + (1 - premise.base_rate) * given_false.belief
+    )
+    prior_denom = 1 - (
+        premise.base_rate * given_true.uncertainty
+        + (1 - premise.base_rate) * given_false.uncertainty
+    )
+    return _from_bd(belief, disbelief, _div(prior_nom, prior_denom))
+
+
+def reduce_opinions(opinions, combine):
+    """Reduce opinions with a pairwise operator, left to right. Empty is None."""
+    if not opinions:
+        return None
+    result = opinions[0]
+    for item in opinions[1:]:
+        result = combine(result, item)
+    return result
+
+
+def opinion_from_stored(stored):
+    """Opinion used for a Solution or Assumption, including unset defaults.
+
+    ``stored`` is None or a dict with any of ``b``, ``d``, ``u``, ``a``.
+    Missing masses follow the vacuous defaults. When belief, disbelief, and
+    uncertainty are all present, uncertainty is kept as stored.
+    """
+    if not isinstance(stored, dict):
+        return vacuous(0.5)
+
+    present = [key for key in ('b', 'd', 'u', 'a') if isinstance(stored.get(key), (int, float))]
+    if not present:
+        return vacuous(0.5)
+
+    belief = float(stored['b']) if 'b' in present else 0.0
+    disbelief = float(stored['d']) if 'd' in present else 0.0
+    base_rate = float(stored['a']) if 'a' in present else 0.5
+    if 'u' in present and 'b' in present and 'd' in present:
+        return Opinion(belief, disbelief, float(stored['u']), base_rate)
+    return opinion(belief, disbelief, base_rate)
+
+
+def as_opinion(stored):
+    """Return an opinion when ``stored`` has all four masses, else None."""
+    if not isinstance(stored, dict):
+        return None
+    if not all(isinstance(stored.get(key), (int, float)) for key in ('b', 'd', 'u', 'a')):
+        return None
+    return Opinion(float(stored['b']), float(stored['d']), float(stored['u']), float(stored['a']))
+
+
+def _has_stored_field(stored):
+    if not isinstance(stored, dict):
+        return False
+    return any(isinstance(stored.get(key), (int, float)) for key in ('b', 'd', 'u', 'a'))
+
+
+def deduce_solved_by_link(child, warrant):
+    """Deduce one solvedBy link.
+
+    A complete warrant is used as stored. When the other warrant has no
+    stored fields, it defaults to the identity opinion. If neither warrant
+    is complete, or one is only partial, the child opinion is passed through.
+    """
+    if not warrant:
+        return child
+    given_true = as_opinion(warrant.get('givenTrue'))
+    given_false = as_opinion(warrant.get('givenFalse'))
+    true_empty = not _has_stored_field(warrant.get('givenTrue'))
+    false_empty = not _has_stored_field(warrant.get('givenFalse'))
+
+    if given_true is not None and given_false is not None:
+        return conditional_deduction(child, given_true, given_false)
+    if given_true is not None and false_empty:
+        return conditional_deduction(child, given_true, IDENTITY_GIVEN_FALSE)
+    if given_false is not None and true_empty:
+        return conditional_deduction(child, IDENTITY_GIVEN_TRUE, given_false)
+    return child
+
+
+def resolve_argument_type(node_type, argument):
+    """How a node combines solvedBy children.
+
+    Goals always use conjunction. Strategies use their argument, or
+    conjunction when it is unset or unknown.
+    """
+    if node_type == 'GoalNode':
+        return 'conjunction'
+    name = str(argument or '').lower()
+    if name in ('conjunction', 'disjunction', 'fusion', 'discount'):
+        return name
+    return 'conjunction'
+
+
+def _combine_opinions(argument_type, opinions):
+    if not opinions:
+        return vacuous(0.5)
+    if len(opinions) == 1:
+        return opinions[0]
+
+    if argument_type == 'discount':
+        result = opinions[0]
+        for trust in opinions[1:]:
+            result = trust_discount(trust, result)
+        return result
+
+    if argument_type == 'disjunction':
+        combine = disjunction
+    elif argument_type == 'fusion':
+        combine = cumulative_fusion
+    else:
+        combine = conjunction
+    return reduce_opinions(opinions, combine) or vacuous(0.5)
+
+
+def try_consume_assumption(support, assumption, warrant):
+    """Unconditional context: ω = ω_A ⊚ (ω_{G|A}, ω_{G|¬A}).
+
+    ω_{G|¬A} must be the edge givenFalse. ω_{G|A} defaults to the current
+    support opinion; a complete edge givenTrue overrides it. Returns None
+    when this link should not consume the assumption.
+    """
+    if not warrant:
+        return None
+    given_false = as_opinion(warrant.get('givenFalse'))
+    if given_false is None:
+        return None
+    given_true = as_opinion(warrant.get('givenTrue'))
+    if given_true is None:
+        given_true = support
+    return conditional_deduction(assumption, given_true, given_false)
+
+
+def propagated_from_links(node_type, argument, stored, solved_by, in_context_of, child_opinion):
+    """Derive one node's opinion from its direct links.
+
+    ``solved_by`` and ``in_context_of`` are sequences of
+    ``(child, child_type, warrant)``. ``child_opinion(child)`` returns the
+    child's propagated :class:`Opinion`. ``warrant`` is None or a dict with
+    ``givenTrue`` and ``givenFalse`` opinion dicts.
+    """
+    if node_type in ('SolutionNode', 'AssumptionNode'):
+        return opinion_from_stored(stored)
+    if node_type in ('GoalNode', 'StrategyNode'):
+        link_opinions = [
+            deduce_solved_by_link(child_opinion(child), warrant)
+            for child, _child_type, warrant in solved_by
+        ]
+        result = _combine_opinions(resolve_argument_type(node_type, argument), link_opinions)
+        for child, child_type, warrant in in_context_of:
+            if child_type != 'AssumptionNode':
+                continue
+            consumed = try_consume_assumption(result, child_opinion(child), warrant)
+            if consumed is not None:
+                result = consumed
+        return result
+    return vacuous(0.5)