%--------------------------------------------------------------------------
% File     : MGT002+7 : TPTP v9.3.1. Released v9.3.0.
% Domain   : Management
% Axioms   : Box-level containment (boxS) for policy redundancy detection
% Version  : [Han98] axioms.
% English  : Encodes box-containment. Presence tags (present/absent) track
%            whether each policy constrains a given axis, enabling the 
%            Unknown-when-absent logic. subs_verdict/6: per-axis 
%            subsumption with presence flags. box_subs/2: binary 
%            aggregation of subs_verdict values; apply iteratively: 
%            box_subs(box_subs(box_subs(S1,S2),S3),S4). Asymmetric: 
%            box_subs(C1,C2) checks C1 is stricter than C2; box_subs(C2,C1)
%            checks the reverse.

% Refs     : [MC+26] Mustafa et al. (2026), Axis Decomposition for ODRL
% Source   : [MC+26]
% Names    : SUBS000-0.ax [MC+26]

% Status   : Satisfiable
% Syntax   : Number of formulae    :   14 (   6 unt;   0 def)
%            Number of atoms       :   40 (  25 equ)
%            Maximal formula atoms :    7 (   2 avg)
%            Number of connectives :   31 (   5   ~;   6   |;  12   &)
%                                         (   0 <=>;   8  =>;   0  <=;   0 <~>)
%            Maximal formula depth :   10 (   5 avg)
%            Maximal term depth    :    2 (   1 avg)
%            Number of predicates  :    4 (   3 usr;   0 prp; 1-4 aty)
%            Number of functors    :    7 (   7 usr;   5 con; 0-6 aty)
%            Number of variables   :   35 (  35   !;   0   ?)
% SPC      : FOF_SAT_RFO_SEQ

% Comments : Requires AXIS001+1.ax and ORD000-0.ax. Continuous domains
%            also requires ORD001-0.ax.
%--------------------------------------------------------------------------
%----Presence tags
%----Encode whether a given policy constrains an axis.
%----Used to implement the Unknown-when-absent logic of def:box-containment.
fof(present_is_presence,axiom,
    is_presence(present) ).

fof(absent_is_presence,axiom,
    is_presence(absent) ).

fof(presence_distinct,axiom,
    present != absent ).

fof(presence_enum,axiom,
    ! [T] :
      ( is_presence(T)
     => ( T = present
        | T = absent ) ) ).

%----Per-axis subsumption verdict with presence
%----subs_verdict(L1,H1,P1, L2,H2,P2):
%----  S_k = Unknown  when C1 or C2 does not constrain axis a_k
%----  S_k = Compatible when both present and sem(C1) subseteq sem(C2)
%----  S_k = Conflict   when both present and sem(C1) not-subseteq sem(C2)
%
%----Note: absence of C2 also yields Unknown (not vacuously Compatible),
%----because the absent policy's intended scope is not known (paper text).
fof(subs_c1_absent,axiom,
    ! [L1,H1,L2,H2] : subs_verdict(L1,H1,absent,L2,H2,present) = unknown ).

fof(subs_c2_absent,axiom,
    ! [L1,H1,L2,H2] : subs_verdict(L1,H1,present,L2,H2,absent) = unknown ).

fof(subs_both_absent,axiom,
    ! [L1,H1,L2,H2] : subs_verdict(L1,H1,absent,L2,H2,absent) = unknown ).

fof(subs_present_yes,axiom,
    ! [L1,H1,L2,H2] :
      ( axis_subsumes(L1,H1,L2,H2)
     => subs_verdict(L1,H1,present,L2,H2,present) = compatible ) ).

fof(subs_present_no,axiom,
    ! [L1,H1,L2,H2] :
      ( ~ axis_subsumes(L1,H1,L2,H2)
     => subs_verdict(L1,H1,present,L2,H2,present) = conflict ) ).

fof(subs_verdict_total,axiom,
    ! [L1,H1,P1,L2,H2,P2] :
      ( ( is_presence(P1)
        & is_presence(P2) )
     => ( subs_verdict(L1,H1,P1,L2,H2,P2) = compatible
        | subs_verdict(L1,H1,P1,L2,H2,P2) = conflict
        | subs_verdict(L1,H1,P1,L2,H2,P2) = unknown ) ) ).

%----Box-level containment aggregation
%----box_subs/2 is BINARY; apply iteratively over all per-axis verdicts:
%----  box_subs(box_subs(box_subs(S1,S2),S3),S4)  for 4 axes.
%
%----box_subs(V1,V2) aggregates per-axis subs_verdict values:
%----  Compatible iff both V1 and V2 are Compatible
%----  Conflict   iff at least one of V1, V2 is Conflict
%----  Unknown    otherwise (mixed Compatible/Unknown, no Conflict)
%
%----ASYMMETRIC by design: box_subs(V1,V2) != box_subs(V2,V1) in general,
%----matching the asymmetry of containment vs. reverse containment.
fof(box_subs_compat,axiom,
    ! [V1,V2] :
      ( ( is_verdict(V1)
        & is_verdict(V2)
        & V1 = compatible
        & V2 = compatible )
     => box_subs(V1,V2) = compatible ) ).

fof(box_subs_conflict,axiom,
    ! [V1,V2] :
      ( ( is_verdict(V1)
        & is_verdict(V2)
        & ( V1 = conflict
          | V2 = conflict ) )
     => box_subs(V1,V2) = conflict ) ).

fof(box_subs_unknown,axiom,
    ! [V1,V2] :
      ( ( is_verdict(V1)
        & is_verdict(V2)
        & ~ ( V1 = compatible
            & V2 = compatible )
        & V1 != conflict
        & V2 != conflict )
     => box_subs(V1,V2) = unknown ) ).

fof(box_subs_total,axiom,
    ! [V1,V2] :
      ( ( is_verdict(V1)
        & is_verdict(V2) )
     => ( box_subs(V1,V2) = compatible
        | box_subs(V1,V2) = conflict
        | box_subs(V1,V2) = unknown ) ) ).

%--------------------------------------------------------------------------