***( Copyright 2021-2022 Extensions of Logic Programming - Universitat Politècnica de València Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. )*** -------------------------------------------------------------------------------- --- To be run on Maude 3.2.1 --- http://maude.cs.uiuc.edu --- --- Based on the theory of --- --- Inductive Reasoning with Equality Predicates, --- Contextual Rewriting and Variant-Based Simplification --- by José Meseguer and Stephen Skeirik --- --- A Fully Syntactic AC-RPO --- by Albert Rubio --- --- Implementation by --- Julia Sapiña --- --- AAC-RPO originally implemented by --- Raúl Gutiérrez --- -------------------------------------------------------------------------------- load file.maude set include BOOL off . fmod NuITP-BOOL is sort NuITP-Bool . op true : -> NuITP-Bool [ ctor ] . op false : -> NuITP-Bool [ ctor ] . endfm fmod NuITP-CLAUSE is pr NuITP-BOOL . sorts Rl Eq EqConj EqDisj ConjEqDisj Clause . subsorts NuITP-Bool < Rl < Eq < EqConj EqDisj < ConjEqDisj . subsort NuITP-Bool < Clause . var E : Eq . var EC EC' : EqConj . vars ED ED' : EqDisj . vars CED CED' CED'' : ConjEqDisj . var CLA : Clause . op _=_ : Universal Universal -> Eq [ comm poly (1 2) ] . op _=>_ : Universal Universal -> Rl [ poly (1 2) ] . op _\/_ : EqDisj EqDisj -> EqDisj [ assoc comm ] . eq true \/ ED = true [ variant ] . eq false \/ ED = ED [ variant ] . eq ED \/ ED = ED [ variant ] . eq ED \/ not(ED) = true [ variant ] . op _/\_ : ConjEqDisj ConjEqDisj -> ConjEqDisj [ assoc comm ] . op _/\_ : EqConj EqConj -> EqConj [ ditto ] . eq true /\ CED = CED [ variant ] . eq false /\ CED = false [ variant ] . eq CED /\ CED = CED [ variant ] . eq CED /\ not(CED) = false [ variant ] . eq CED \/ (CED' /\ CED'') = (CED \/ CED') /\ (CED \/ CED'') . op _->_ : ConjEqDisj ConjEqDisj -> Clause . op _->_ : EqConj EqDisj -> Clause . eq CED -> CED = true . eq CED -> true = true . eq true -> false = false . eq false -> CED = true . eq (E /\ EC) -> ((E \/ ED) /\ CED) = ((E /\ EC) -> CED) . eq (((E \/ ED) /\ EC) -> CED) = ((E /\ EC) -> CED) /\ ((ED /\ EC) -> CED) . eq EC -> ((E /\ EC) \/ ED) /\ CED = EC -> (E \/ ED) /\ (EC /\ ED) /\ EC . eq EC -> ED /\ (ED \/ ED') /\ CED = EC -> ED /\ CED . eq ED /\ (ED \/ ED') = ED . op not_ : Clause -> NuITP-Bool . op not_ : ConjEqDisj -> NuITP-Bool . eq not(true) = false [ variant ] . eq not(false) = true [ variant ] . eq not(not(CED)) = CED [ variant ] . eq not(not(CLA)) = CLA [ variant ] . endfm fmod NuITP-DNF is pr NuITP-CLAUSE . vars CED CED' CED'' : ConjEqDisj . eq CED -> CED' = not(CED) \/ CED' . eq not(CED /\ CED') = not(CED) \/ not(CED') . eq not(CED \/ CED') = not(CED) /\ not(CED') . eq CED /\ (CED' \/ CED'') = (CED /\ CED') \/ (CED /\ CED'') . endfm fmod NuITP-CNF is pr NuITP-CLAUSE . vars CED CED' CED'' : ConjEqDisj . eq CED -> CED' = not(CED) \/ CED' . eq not(CED /\ CED') = not(CED) \/ not(CED') . eq not(CED \/ CED') = not(CED) /\ not(CED') . eq CED \/ (CED' /\ CED'') = (CED \/ CED') /\ (CED \/ CED'') . endfm set include BOOL on . fmod NuITP-UTILS is pr META-LEVEL . pr CONVERSION . var M : Module . vars Q Q' F : Qid . var IL : ImportList . vars SS SS' : SortSet . vars SSDS SSDS' : SubsortDeclSet . vars OPDS OPDS' : OpDeclSet . var MAS : MembAxSet . vars EQS EQS' EQS'' : EquationSet . vars RLS RLS' : RuleSet . var STDS : StratDeclSet . var STDFS : StratDefSet . var STR : String . var TY : Type . var TYL : TypeList . var K : Kind . var N : Nat . var AT : Attr . vars ATS ATS' : AttrSet . var C : Constant . var V : Variable . vars T T' LHS RHS GAMMA : Term . var SB : Substitution . var SBS : SubstitutionSet . var NTL : NeTermList . vars COND COND' : Condition . var GT : GroundTerm . var S : Sort . var TL : TermList . vars TS TS' SKO : TermSet . var NTS : NeTermSet . var COL : NeCTermList . var CO : Context . var NTYL : NeTypeList . op NuITP-VERSION : -> String . eq NuITP-VERSION = "alpha 14" . ops RED GREEN YELLOW CYAN WHITE BW : -> String . eq RED = "\033[1;31m" . eq GREEN = "\033[1;32m" . eq YELLOW = "\033[1;33m" . eq CYAN = "\033[1;36m" . eq WHITE = "\033[1;37m" . eq BW = "\033[0m" . sorts NeTermSet TermSet . subsort Term < NeTermSet < TermSet . op mt : -> TermSet [ ctor ] . op _;;_ : TermSet TermSet -> TermSet [ assoc comm id: mt ] . op _;;_ : NeTermSet TermSet -> NeTermSet [ assoc comm id: mt ] . eq T:Term ;; T:Term = T:Term . sort SubstitutionSet . subsort Substitution < SubstitutionSet . op mt : -> SubstitutionSet [ ctor ] . op _|_ : SubstitutionSet SubstitutionSet -> SubstitutionSet [ assoc comm id: mt ] . eq SB:Substitution | SB:Substitution = SB:Substitution . sort StringList . subsort String < StringList . op nil : -> StringList [ ctor ] . op __ : StringList StringList -> StringList [ ctor assoc id: nil ] . op {_,_} : OpDeclSet EquationSet -> ResultPair [ ctor ] . op getOps : ResultPair -> OpDeclSet . eq getOps({ OPDS , EQS }) = OPDS . op getEqs : ResultPair -> EquationSet . eq getEqs({ OPDS , EQS }) = EQS . op {_,_,_} : SortSet SubsortDeclSet OpDeclSet -> ResultTriple [ ctor ] . op getSorts : ResultTriple -> SortSet . eq getSorts({ SS , SSDS , OPDS }) = SS . op getSubsorts : ResultTriple -> SubsortDeclSet . eq getSubsorts({ SS , SSDS , OPDS }) = SSDS . op getOps : ResultTriple -> OpDeclSet . eq getOps({ SS , SSDS , OPDS }) = OPDS . op getRule : Module Qid -> RuleSet . eq getRule(M, F) = getRule(getRls(M), F) . op getRule : RuleSet Qid -> RuleSet . eq getRule((rl LHS => RHS [ label(F) ATS ] .) RLS, F) = (rl LHS => RHS [ label(F) ATS ] .) . eq getRule(RLS, F) = none [ owise ] . op extModule : Qid -> Module . eq extModule(Q) = addImport(upModule(Q, true), 'NuITP-CLAUSE) . op redModule : Module TermSet -> Module . eq redModule(M, SKO) = addOps(setEqs(M, none), SKO) . op addImport : Module Qid -> Module . eq addImport(fmod Q is IL sorts SS . SSDS OPDS MAS EQS endfm, Q') = fmod Q is IL (protecting Q' .) sorts SS . SSDS OPDS MAS EQS endfm . eq addImport(mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS endm, Q') = mod Q is IL (protecting Q' .) sorts SS . SSDS OPDS MAS EQS RLS endm . eq addImport(smod Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm, Q') = smod Q is IL (protecting Q' .) sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm . eq addImport(fth Q is IL sorts SS . SSDS OPDS MAS EQS endfth, Q') = fth Q is IL (protecting Q' .) sorts SS . SSDS OPDS MAS EQS endfth . eq addImport(th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth, Q') = th Q is IL (protecting Q' .) sorts SS . SSDS OPDS MAS EQS RLS endth . eq addImport(sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth, Q') = sth Q is IL (protecting Q' .) sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth . eq addImport(M, Q') = M [ owise ] . op addSorts : Module SortSet -> Module . eq addSorts(fmod Q is IL sorts SS . SSDS OPDS MAS EQS endfm, SS') = fmod Q is IL sorts SS ; SS' . SSDS OPDS MAS EQS endfm . eq addSorts(mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS endm, SS') = mod Q is IL sorts SS ; SS' . SSDS OPDS MAS EQS RLS endm . eq addSorts(smod Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm, SS') = smod Q is IL sorts SS ; SS' . SSDS OPDS MAS EQS RLS STDS STDFS endsm . eq addSorts(fth Q is IL sorts SS . SSDS OPDS MAS EQS endfth, SS') = fth Q is IL sorts SS ; SS' . SSDS OPDS MAS EQS endfth . eq addSorts(th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth, SS') = th Q is IL sorts SS ; SS' . SSDS OPDS MAS EQS RLS endth . eq addSorts(sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth, SS') = sth Q is IL sorts SS ; SS' . SSDS OPDS MAS EQS RLS STDS STDFS endsth . eq addSorts(M, SS) = M [ owise ] . op addSubSorts : Module SubsortDeclSet -> Module . eq addSubSorts(fmod Q is IL sorts SS . SSDS OPDS MAS EQS endfm, SSDS') = fmod Q is IL sorts SS . SSDS SSDS' OPDS MAS EQS endfm . eq addSubSorts(mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS endm, SSDS') = mod Q is IL sorts SS . SSDS SSDS' OPDS MAS EQS RLS endm . eq addSubSorts(smod Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm, SSDS') = smod Q is IL sorts SS . SSDS SSDS' OPDS MAS EQS RLS STDS STDFS endsm . eq addSubSorts(fth Q is IL sorts SS . SSDS OPDS MAS EQS endfth, SSDS') = fth Q is IL sorts SS . SSDS SSDS' OPDS MAS EQS endfth . eq addSubSorts(th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth, SSDS') = th Q is IL sorts SS . SSDS SSDS' OPDS MAS EQS RLS endth . eq addSubSorts(sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth, SSDS') = sth Q is IL sorts SS . SSDS SSDS' OPDS MAS EQS RLS STDS STDFS endsth . eq addSubSorts(M, SSDS) = M [ owise ] . op addOps : Module TermSet -> Module . eq addOps(M, TS) = addOps(M, toOps(TS)) . op addOps : Module OpDeclSet -> Module . eq addOps(fmod Q is IL sorts SS . SSDS OPDS MAS EQS endfm, OPDS') = fmod Q is IL sorts SS . SSDS OPDS OPDS' MAS EQS endfm . eq addOps(mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS endm, OPDS') = mod Q is IL sorts SS . SSDS OPDS OPDS' MAS EQS RLS endm . eq addOps(smod Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm, OPDS') = smod Q is IL sorts SS . SSDS OPDS OPDS' MAS EQS RLS STDS STDFS endsm . eq addOps(fth Q is IL sorts SS . SSDS OPDS MAS EQS endfth, OPDS') = fth Q is IL sorts SS . SSDS OPDS OPDS' MAS EQS endfth . eq addOps(th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth, OPDS') = th Q is IL sorts SS . SSDS OPDS OPDS' MAS EQS RLS endth . eq addOps(sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth, OPDS') = sth Q is IL sorts SS . SSDS OPDS OPDS' MAS EQS RLS STDS STDFS endsth . eq addOps(M, OPDS) = M [ owise ] . op setOps : Module OpDeclSet -> Module . eq setOps(fmod Q is IL sorts SS . SSDS OPDS MAS EQS endfm, OPDS') = fmod Q is IL sorts SS . SSDS OPDS' MAS EQS endfm . eq setOps(mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS endm, OPDS') = mod Q is IL sorts SS . SSDS OPDS' MAS EQS RLS endm . eq setOps(smod Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm, OPDS') = smod Q is IL sorts SS . SSDS OPDS' MAS EQS RLS STDS STDFS endsm . eq setOps(fth Q is IL sorts SS . SSDS OPDS MAS EQS endfth, OPDS') = fth Q is IL sorts SS . SSDS OPDS' MAS EQS endfth . eq setOps(th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth, OPDS') = th Q is IL sorts SS . SSDS OPDS' MAS EQS RLS endth . eq setOps(sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth, OPDS') = sth Q is IL sorts SS . SSDS OPDS' MAS EQS RLS STDS STDFS endsth . eq setOps(M, OPDS) = M [ owise ] . op addEqs : Module TermSet -> Module . eq addEqs(M, TS) = addEqs(M, toEqs(TS)) . op addEqs : Module EquationSet -> Module . eq addEqs(fmod Q is IL sorts SS . SSDS OPDS MAS EQS endfm, EQS') = fmod Q is IL sorts SS . SSDS OPDS MAS EQS EQS' endfm . eq addEqs(mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS endm, EQS') = mod Q is IL sorts SS . SSDS OPDS MAS EQS EQS' RLS endm . eq addEqs(smod Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm, EQS') = smod Q is IL sorts SS . SSDS OPDS MAS EQS EQS' RLS STDS STDFS endsm . eq addEqs(fth Q is IL sorts SS . SSDS OPDS MAS EQS endfth, EQS') = fth Q is IL sorts SS . SSDS OPDS MAS EQS EQS' endfth . eq addEqs(th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth, EQS') = th Q is IL sorts SS . SSDS OPDS MAS EQS EQS' RLS endth . eq addEqs(sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth, EQS') = sth Q is IL sorts SS . SSDS OPDS MAS EQS EQS' RLS STDS STDFS endsth . eq addEqs(M, EQS) = M [ owise ] . op setEqs : Module EquationSet -> Module . eq setEqs(fmod Q is IL sorts SS . SSDS OPDS MAS EQS endfm, EQS') = fmod Q is IL sorts SS . SSDS OPDS MAS EQS' endfm . eq setEqs(mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS endm, EQS') = mod Q is IL sorts SS . SSDS OPDS MAS EQS' RLS endm . eq setEqs(smod Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm, EQS') = smod Q is IL sorts SS . SSDS OPDS MAS EQS' RLS STDS STDFS endsm . eq setEqs(fth Q is IL sorts SS . SSDS OPDS MAS EQS endfth, EQS') = fth Q is IL sorts SS . SSDS OPDS MAS EQS' endfth . eq setEqs(th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth, EQS') = th Q is IL sorts SS . SSDS OPDS MAS EQS' RLS endth . eq setEqs(sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth, EQS') = sth Q is IL sorts SS . SSDS OPDS MAS EQS' RLS STDS STDFS endsth . eq setEqs(M, EQS) = M [ owise ] . op addRls : Module TermSet -> Module . eq addRls(M, TS) = addRls(M, toRls(TS)) . op addRls : Module RuleSet -> Module . eq addRls(fmod Q is IL sorts SS . SSDS OPDS MAS EQS endfm, RLS) = mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS endm . eq addRls(mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS endm, RLS') = mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS RLS' endm . eq addRls(smod Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm, RLS') = smod Q is IL sorts SS . SSDS OPDS MAS EQS RLS RLS' STDS STDFS endsm . eq addRls(fth Q is IL sorts SS . SSDS OPDS MAS EQS endfth, RLS) = th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth . eq addRls(th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth, RLS') = th Q is IL sorts SS . SSDS OPDS MAS EQS RLS RLS' endth . eq addRls(sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth, RLS') = sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS RLS' STDS STDFS endsth . eq addRls(M, RLS) = M [ owise ] . op setRls : Module RuleSet -> Module . eq setRls(fmod Q is IL sorts SS . SSDS OPDS MAS EQS endfm, RLS) = mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS endm . eq setRls(mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS endm, RLS') = mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS RLS' endm . eq setRls(smod Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm, RLS') = smod Q is IL sorts SS . SSDS OPDS MAS EQS RLS RLS' STDS STDFS endsm . eq setRls(fth Q is IL sorts SS . SSDS OPDS MAS EQS endfth, RLS) = th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth . eq setRls(th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth, RLS') = th Q is IL sorts SS . SSDS OPDS MAS EQS RLS RLS' endth . eq setRls(sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth, RLS') = sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS RLS' STDS STDFS endsth . eq setRls(M, RLS) = M [ owise ] . op toOps : TermList -> OpDeclSet . op toOps : TermSet -> OpDeclSet . eq toOps(empty) = none . eq toOps(mt) = none . eq toOps(C) = (op getName(C) : nil -> getType(C) [ metadata("skolem") ] .) . eq toOps((C, NTL)) = (op getName(C) : nil -> getType(C) [ metadata("skolem") ] .) toOps(NTL) . eq toOps((C ;; NTS)) = (op getName(C) : nil -> getType(C) [ metadata("skolem") ] .) toOps(NTS) . op toCondition : NeTermList -> Condition . eq toCondition('true.NuITP-Bool) = nil . eq toCondition('_=_[LHS,RHS]) = (LHS = RHS) . eq toCondition('_=>_[LHS,RHS]) = (LHS = RHS) . eq toCondition('_/\_[T,NTL]) = toCondition(T) /\ toCondition(NTL) . eq toCondition((T,NTL)) = toCondition(T) /\ toCondition(NTL) . op toEqs : TermList -> EquationSet . op toEqs : TermSet -> EquationSet . eq toEqs(empty) = none . eq toEqs(mt) = none . eq toEqs('_/\_[NTL]) = toEqs(NTL) . eq toEqs('_\/_[NTL]) = toEqs(NTL) . eq toEqs('_->_[GAMMA, '_=_[LHS, RHS]]) = if (GAMMA == 'true.NuITP-Bool) then (eq LHS = RHS [ none ] .) else (ceq LHS = RHS if toCondition(GAMMA) [ none ] .) fi . eq toEqs('_->_[GAMMA, '_=>_[LHS, RHS]]) = if (GAMMA == 'true.NuITP-Bool) then (eq LHS = RHS [ none ] .) else (ceq LHS = RHS if toCondition(GAMMA) [ none ] .) fi . eq toEqs('_=_[LHS, RHS]) = (eq LHS = RHS [ none ] .) . eq toEqs('_=>_[LHS, RHS]) = (eq LHS = RHS [ none ] .) . eq toEqs(T) = none [ owise ] . eq toEqs((T, NTL)) = toEqs(T) toEqs(NTL) . eq toEqs((T ;; NTS)) = toEqs(T) toEqs(NTS) . op toRls : EquationSet -> RuleSet . eq toRls((none).EquationSet) = none . eq toRls((eq LHS = RHS [ variant ATS ] .) EQS) = (rl LHS => RHS [ narrowing ATS ] .) toRls(EQS) . eq toRls((eq LHS = RHS [ owise ATS ] .) EQS) = (rl LHS => RHS [ ATS ] .) toRls(EQS) . eq toRls((eq LHS = RHS [ ATS ] .) EQS) = (rl LHS => RHS [ narrowing ATS ] .) toRls(EQS) [ owise ] . eq toRls((ceq LHS = RHS if COND [ ATS ] .) EQS) = (crl LHS => RHS if COND [ ATS ] .) toRls(EQS) . op toRls : EquationSet Nat -> RuleSet . eq toRls((none).EquationSet, N) = none . eq toRls((eq LHS = RHS [ variant ATS ] .) EQS, N) = (rl LHS => RHS [ narrowing label(qid("NuITP-RL#" + string(N,10))) ] .) toRls(EQS, N + 1) . eq toRls((eq LHS = RHS [ owise ATS ] .) EQS, N) = (rl LHS => RHS [ label(qid("NuITP-RL#" + string(N,10)))] .) toRls(EQS, N + 1) . eq toRls((eq LHS = RHS [ ATS ] .) EQS, N) = (rl LHS => RHS [ narrowing label(qid("NuITP-RL#" + string(N,10))) ] .) toRls(EQS, N + 1) [ owise ] . eq toRls((ceq LHS = RHS if COND [ ATS ] .) EQS, N) = (crl LHS => RHS if COND [ ATS label(qid("NuITP-RL#" + string(N,10)))] .) toRls(EQS, N + 1) . --- Just for arguments in disjunctions op disorient : TermList -> TermList . eq disorient(empty) = empty . eq disorient('_=_[NTL]) = '_=_[NTL] . eq disorient('_/\_[NTL]) = '_/\_[disorient(NTL)] . eq disorient('_\/_[NTL]) = '_\/_[disorient(NTL)] . eq disorient('_=>_[NTL]) = '_=_[NTL] . eq disorient('_->_[LHS,RHS]) = '_->_[LHS,disorient(RHS)] . eq disorient((T,NTL)) = disorient(T),disorient(NTL) . eq disorient(T) = T [ owise ] . --- Non-oriented equations cannot be converted into rules op toRls : TermList -> RuleSet . op toRls : TermSet -> RuleSet . eq toRls(empty) = none . eq toRls(mt) = none . eq toRls('_->_[GAMMA,'_\/_[NTL]]) = if (GAMMA == 'true.NuITP-Bool) then (rl '_\/_[disorient(NTL)] => 'true.NuITP-Bool [ narrowing ] .) else (crl '_\/_[disorient(NTL)] => 'true.NuITP-Bool if toCondition(GAMMA) [ none ] .) fi . eq toRls('_->_[GAMMA, '_=>_[LHS, RHS]]) = if (GAMMA == 'true.NuITP-Bool) then (rl LHS => RHS [ narrowing ] .) else (crl LHS => RHS if toCondition(GAMMA) [ none ] .) fi . eq toRls('_=>_[LHS, RHS]) = (rl LHS => RHS [ narrowing ] .) . eq toRls(T) = none [ owise ] . eq toRls((T, NTL)) = toRls(T) toRls(NTL) . eq toRls((T ;; NTS)) = toRls(T) toRls(NTS) . --- For Equality Rule op toRls : Term Substitution -> RuleSet . eq toRls('_->_[GAMMA,'_=>_[LHS,RHS]], SB) = toRls(LHS, RHS, GAMMA, SB) . op toRls : Term Term Term Substitution -> RuleSet . eq toRls(LHS, RHS, 'true.NuITP-Bool, SB) = (rl applySub(LHS, SB) => applySub(RHS, SB) [nonexec label('NuITP-EQRL)] .) . eq toRls(LHS, RHS, GAMMA, SB) = (crl applySub(LHS, SB) => applySub(RHS, SB) if toCondition(applySub(GAMMA, SB)) [nonexec label('NuITP-EQRL)] .) [ owise ] . op getVars : TermList -> TermSet . op getVars : TermSet -> TermSet . eq getVars(empty) = mt . eq getVars(mt) = mt . eq getVars(C) = mt . eq getVars(V) = V . eq getVars(F[NTL]) = getVars(NTL) . eq getVars((T, NTL)) = getVars(T) ;; getVars(NTL) . eq getVars((T ;; NTS)) = getVars(T) ;; getVars(NTS) . op getRanVars : Substitution -> TermSet . eq getRanVars(none) = mt . eq getRanVars(V <- T ; SB) = getVars(T) ;; getRanVars(SB) . op cleanString : Type -> String . eq cleanString(TY) = removeEsc(string(TY)) . op cleanString : Kind -> String . eq cleanString(K) = removeEsc(string(K)) . op removeEsc : String -> String . eq removeEsc(STR) = STR [ owise ] . ceq removeEsc(STR) = removeEsc(substr(STR,0,rfind(STR, "`", length(STR) + 1)) + substr(STR,rfind(STR, "`", length(STR)) + 1,length(STR))) if rfind(STR, "`", length(STR) + 1) =/= notFound . op safeString : Qid -> String . eq safeString(Q) = safeString(string(Q)) . op safeString : String -> String . ceq safeString(STR) = safeString(substr(STR, 0, N) + "-NuITP-USC-" + substr(STR, s(N), length(STR))) if N := find(STR, "_", 0) . ceq safeString(STR) = safeString(substr(STR, 0, N) + "-NuITP-CMM-" + substr(STR, s(N), length(STR))) if N := find(STR, ",", 0) . eq safeString(STR) = STR [ owise ] . op safeVars : Equation String -> Equation . eq safeVars((eq LHS = RHS [ ATS ] .), STR) = (eq safeVars(LHS, STR) = safeVars(RHS, STR) [safeVars(ATS, STR)] .) . eq safeVars((ceq LHS = RHS if COND [ ATS ] .), STR) = (ceq safeVars(LHS, STR) = safeVars(RHS, STR) if safeVars(COND, STR) [safeVars(ATS, STR)] .) . op safeVars : TermList String -> TermList . op safeVars : Term String -> Term . eq safeVars(empty, STR) = empty . eq safeVars(GT, STR) = GT . eq safeVars(V, STR) = if ((substr(string(V), 0, 1) == "#") or-else (substr(string(V), 0, 1) == "%") or-else (substr(string(V), 0, 1) == "@")) then qid(STR + (string(V))) else V fi . eq safeVars(F[NTL], STR) = F[safeVars(NTL, STR)] . eq safeVars((T, NTL), STR) = (safeVars(T, STR), safeVars(NTL, STR)) . op safeVars : Condition String -> Condition . eq safeVars((nil).Condition, STR) = nil . eq safeVars((T : S) /\ COND, STR) = (safeVars(T, STR) : S) /\ safeVars(COND, STR) . eq safeVars((T = T') /\ COND, STR) = (safeVars(T, STR) = safeVars(T', STR)) /\ safeVars(COND, STR) . eq safeVars((T => T') /\ COND, STR) = (safeVars(T, STR) => safeVars(T', STR)) /\ safeVars(COND, STR) . eq safeVars((T' := T) /\ COND, STR) = (safeVars(T', STR) := safeVars(T, STR)) /\ safeVars(COND, STR) . op safeVars : AttrSet String -> AttrSet . eq safeVars(id(T) ATS, STR) = id(safeVars(T, STR)) safeVars(ATS, STR) . eq safeVars(left-id(T) ATS, STR) = left-id(safeVars(T, STR)) safeVars(ATS, STR) . eq safeVars(right-id(T) ATS, STR) = right-id(safeVars(T, STR)) safeVars(ATS, STR) . eq safeVars(ATS, STR) = ATS [ owise ] . op saferVars : SubstitutionSet String -> SubstitutionSet . eq saferVars((mt).SubstitutionSet, STR) = mt . eq saferVars((none).Substitution, STR) = none . eq saferVars(V <- T ; SB, STR) = safeVars(V, STR) <- safeVars(T, STR) ; saferVars(SB,STR) . eq saferVars(SB | SBS, STR) = saferVars(SB,STR) | saferVars(SBS,STR) [ owise ] . op safeVars : SubstitutionSet String -> SubstitutionSet . eq safeVars((mt).SubstitutionSet, STR) = mt . eq safeVars((none).Substitution, STR) = none . eq safeVars(V <- T ; SB, STR) = V <- safeVars(T, STR) ; safeVars(SB,STR) . eq safeVars(SB | SBS, STR) = safeVars(SB,STR) | safeVars(SBS,STR) [ owise ] . op fresh : String Type -> Variable . eq fresh(STR, TY) = qid(STR + ":" + substr(string(TY), 0, length(string(TY)))) . op fresh : String TypeList Nat -> TermList . eq fresh(STR, nil, N) = empty . eq fresh(STR, TY TYL, N) = qid(STR + string(N, 10) + ":" + substr(string(TY), 0, length(string(TY)))) , fresh(STR, TYL, s(N)) . op _inS_ : Sort SortSet -> Bool . eq S inS (S ; SS) = true . eq S inS SS = false [ owise ] . op _in_ : AttrSet AttrSet -> Bool . eq AT in AT ATS = true . eq AT in ATS = false [ owise ] . op _in_ : Term TermList -> Bool . eq T in T = true . eq T in F[NTL] = T in NTL . eq T in (T',NTL) = T in T' or-else T in NTL . eq T in TL = false [ owise ] . --- For generator sets op _notIn_ : TermSet TermSet -> Bool . eq (V ;; TS) notIn (V ;; TS') = false . eq TS notIn TS' = true [ owise ] . op _in_ : TermSet TermSet -> Bool . eq TS in (TS ;; TS') = true . eq TS in TS' = false [ owise ] . op applySub : TermSet Substitution -> TermSet . op applySub : TermList Substitution -> TermList . op applySub : Term Substitution -> Term . eq applySub(mt, SB) = mt . eq applySub(empty, SB) = empty . eq applySub(V, (V <- T ; SB)) = T . eq applySub(F[NTL], SB) = F[applySub(NTL, SB)] . eq applySub((T, NTL), SB) = applySub(T, SB), applySub(NTL, SB) . eq applySub((T ;; NTS), SB) = applySub(T,SB) ;; applySub(NTS,SB) . eq applySub(T, SB) = T [ owise ] . op isNarrowex : Module Term -> Bool . eq isNarrowex(M, F[NTL]) = not(isCtor?(getOps(M), F[NTL])) and-then isCtor?(getOps(M), NTL) and-then metaNarrowingApply(M, F[NTL], empty,'#, none, 0) :: NarrowingApplyResult . eq isNarrowex(M, T) = false [ owise ] . op isCtor? : Module TermSet -> Bool . op isCtor? : Module TermList -> Bool . op isCtor? : Module Term -> Bool . eq isCtor?(M, mt) = true . eq isCtor?(M, T) = isCtor?(getOps(M), T) . eq isCtor?(M, T ;; NTS) = isCtor?(getOps(M), T) and-then isCtor?(M, NTS) . eq isCtor?(M, (T, NTL)) = isCtor?(getOps(M), T) and-then isCtor?(M, NTL) . op isCtor? : OpDeclSet TermList -> Bool . eq isCtor?(OPDS, C) = true . eq isCtor?(OPDS, V) = true . eq isCtor?((op F : NTYL -> TY [ ctor ATS ] .) OPDS, F[NTL]) = isCtor?((op F : NTYL -> TY [ ctor ATS ] .) OPDS, NTL) . eq isCtor?((op F : NTYL -> TY [ ATS ] .) OPDS, F[NTL]) = false [ owise ] . eq isCtor?(OPDS, (T, NTL)) = isCtor?(OPDS, T) and-then isCtor?(OPDS, NTL) . op replaceHole : Context Term -> Term . eq replaceHole([],T) = T . eq replaceHole(F[COL],T) = F[replaceHole(COL,T)] . eq replaceHole((CO,TL),T) = (replaceHole(CO,T),TL) [ owise ] . eq replaceHole((T,COL),T') = (T,replaceHole(COL,T')) [ owise ] . op getTerms : Condition -> TermSet . eq getTerms(nil) = mt . eq getTerms((T : S)) = T . eq getTerms((T = T')) = T ;; T' . eq getTerms((T' := T)) = T ;; T' . eq getTerms((T => T')) = T ;; T' . eq getTerms(COND /\ COND') = getTerms(COND) ;; getTerms(COND') . op toPattern : Module Term String -> Term . eq toPattern(M, C, STR) = C . eq toPattern(M, F[NTL], STR) = F[fresh(STR, getTypeList(M, NTL), 0)] . op getTypeList : Module TermList -> TypeList . eq getTypeList(M, empty) = nil . eq getTypeList(M, T) = leastSort(M, T) . eq getTypeList(M, (T, NTL)) = leastSort(M, T) getTypeList(M, NTL) . op ssc : Module Rule -> TermSet . eq ssc(M, rl LHS => RHS [ ATS ] .) = ssc(M, toPattern(M, LHS, "NuITP-SSC#"), RHS) . eq ssc(M, crl LHS => RHS if COND [ ATS ] .) = ssc(M, toPattern(M, LHS, "NuITP-SSC#"), RHS ;; getTerms(COND)) . op ssc : Module Term TermSet -> TermSet . eq ssc(M, LHS, mt) = mt . eq ssc(M, LHS, T) = ssc(M, LHS, T, 0) . eq ssc(M, LHS, T ;; NTS) = ssc(M, LHS, T) ;; ssc(M, LHS, NTS) . op ssc : Module Term Term Nat -> TermSet . ceq ssc(M, F[NTL], T, N) = if isCtor?(M, applySub(NTL, SB)) then applySub(F[NTL], SB) else mt fi ;; ssc(M, F[NTL], T, N + 1) if { SB , CO } := metaXmatch(M, F[NTL], T, nil, 0, unbounded, N) . eq ssc(M, LHS, T, N) = mt [ owise ] . op subTerms : NeTermList -> TermSet . eq subTerms(F[NTL]) = (F[NTL]) ;; subTerms(NTL) . eq subTerms((T,NTL)) = subTerms(T) ;; subTerms(NTL) . eq subTerms(T) = T [ owise ] . op subTerms : Condition -> TermSet . eq subTerms((nil).Condition) = mt . eq subTerms(T : S) = subTerms(T) . eq subTerms(T = T') = subTerms(T) ;; subTerms(T') . eq subTerms(T' := T) = subTerms(T) ;; subTerms(T') . eq subTerms(T => T') = subTerms(T) ;; subTerms(T') . eq subTerms(COND /\ COND') = subTerms(COND) ;; subTerms(COND') [ owise ] . op subTerms : EquationSet -> TermSet . eq subTerms((eq LHS = RHS [ ATS ] .) EQS) = subTerms(LHS) ;; subTerms(RHS) ;; subTerms(EQS) . eq subTerms((ceq LHS = RHS if COND [ ATS ] .) EQS) = subTerms(LHS) ;; subTerms(RHS) ;; subTerms(COND) ;; subTerms(EQS) . eq subTerms(EQS) = mt [ owise ] . op omega : Module -> Module . eq omega(M) = setOps(setEqs(M, none), omega(getOps(M))) . op omega : OpDeclSet -> OpDeclSet . --- TODO: Sorts? eq omega((op F : TYL -> TY [ ctor ATS ] .) OPDS) = (op F : TYL -> TY [ ctor ATS ] .) omega(OPDS) . eq omega(OPDS) = none [ owise ] . op isOmega? : Module NeTermList -> Bool . eq isOmega?(M, (T,NTL)) = isOmega?(M, T) and-then isOmega?(M, NTL) . eq isOmega?(M, '_->_[T,T']) = isOmega?(M, T) and-then isOmega?(M, T') . eq isOmega?(M, '_\/_[T,NTL]) = isOmega?(M, T) and-then isOmega?(M, NTL) . eq isOmega?(M, '_/\_[T,NTL]) = isOmega?(M, T) and-then isOmega?(M, NTL) . eq isOmega?(M, '_=_[LHS,RHS]) = isOmega?(M, LHS) and-then isOmega?(M, RHS) . eq isOmega?(M, '_=>_[LHS,RHS]) = isOmega?(M, LHS) and-then isOmega?(M, RHS) . eq isOmega?(M, T) = isOmega?'(M, getOps(omega(M)) getOps(upModule('NuITP-CLAUSE,true)), T) [ owise ] . op isOmega?' : Module OpDeclSet TermList -> Bool . eq isOmega?'(M, OPDS, empty) = true . eq isOmega?'(M, OPDS, V) = true . ceq isOmega?'(M, (op F : nil -> TY [ ATS ] .) OPDS, C) = true if (getName(C) == F) and-then (getType(C) == TY) . eq isOmega?'(M, OPDS, C) = false [ owise ] . ceq isOmega?'(M, (op F : NTYL -> TY [ ATS ] .) OPDS, F[NTL]) = isOmega?'(M, (op F : NTYL -> TY [ ATS ] .) OPDS, NTL) if SB := metaMatch(M, F[fresh("NuITP-OM",NTYL, 0)], F[NTL], nil, 0) . eq isOmega?'(M, OPDS, F[NTL]) = false [ owise ] . eq isOmega?'(M, OPDS, (T, NTL)) = isOmega?'(M, OPDS, T) and-then isOmega?'(M, OPDS, NTL) . op sigma1 : Module -> Module . --- TODO: Sorts? eq sigma1(M) = setOps(setEqs(M, sigma1(getEqs(M))), sigma1(M, getOps(M), subTerms(sigma1(getEqs(M))))) . op sigma1 : EquationSet -> EquationSet . --- owise or conditional eqs are not in sigma1 eq sigma1((eq LHS = RHS [ variant ATS ] .) EQS) = (eq LHS = RHS [ variant ATS ] .) sigma1(EQS) . eq sigma1(EQS) = none [ owise ] . op sigma1 : Module OpDeclSet TermSet -> OpDeclSet . eq sigma1(M, (op F : TYL -> TY [ ctor ATS ] .) OPDS, TS) = (op F : TYL -> TY [ ctor ATS ] .) sigma1(M, OPDS, TS) . eq sigma1(M, (op F : nil -> TY [ ATS metadata("skolem") ] .) OPDS, TS) = (op F : nil -> TY [ ATS metadata("skolem") ] .) sigma1(M, OPDS, TS) . ceq sigma1(M, (op F : nil -> TY [ ATS ] .) OPDS, (C ;; TS)) = (op F : nil -> TY [ ATS ] .) sigma1(M, OPDS, (C ;; TS)) if getName(C) == F and-then getType(C) == TY . ceq sigma1(M, (op F : NTYL -> TY [ ATS ] .) OPDS, ((F[NTL]) ;; TS)) = (op F : NTYL -> TY [ ATS ] .) sigma1(M, OPDS, ((F[NTL]) ;; TS)) if SB := metaMatch(M, F[fresh("NuITP-S1",NTYL, 0)], F[NTL], nil, 0) . eq sigma1(M, OPDS, TS) = none [ owise ] . op isSigma1? : Module TermList -> Bool . eq isSigma1?(M, empty) = false . --- Call from SUBL/SUBR eq isSigma1?(M, (T,NTL)) = isSigma1?(M, T) and-then isSigma1?(M, NTL) . eq isSigma1?(M, '_->_[T,T']) = isSigma1?(M, T) and-then isSigma1?(M, T') . eq isSigma1?(M, '_\/_[T,NTL]) = isSigma1?(M, T) and-then isSigma1?(M, NTL) . eq isSigma1?(M, '_/\_[T,NTL]) = isSigma1?(M, T) and-then isSigma1?(M, NTL) . eq isSigma1?(M, '_=_[LHS,RHS]) = isSigma1?(M, LHS) and-then isSigma1?(M, RHS) . eq isSigma1?(M, '_=>_[LHS,RHS]) = isSigma1?(M, LHS) and-then isSigma1?(M, RHS) . eq isSigma1?(M, T) = isSigma1?'(M, getOps(sigma1(M)) getOps(upModule('NuITP-CLAUSE,true)), T) [ owise ] . op isSigma1?' : Module OpDeclSet TermList -> Bool . eq isSigma1?'(M, OPDS, empty) = true . eq isSigma1?'(M, OPDS, V) = true . ceq isSigma1?'(M, (op F : nil -> TY [ ATS ] .) OPDS, C) = true if (getName(C) == F) and-then (getType(C) == TY) . eq isSigma1?'(M, OPDS, C) = false [ owise ] . ceq isSigma1?'(M, (op F : NTYL -> TY [ ATS ] .) OPDS, F[NTL]) = isSigma1?'(M, (op F : NTYL -> TY [ ATS ] .) OPDS, NTL) if SB := metaMatch(M, F[fresh("NuITP-S1",NTYL, 0)], F[NTL], nil, 0) . eq isSigma1?'(M, OPDS, F[NTL]) = false [ owise ] . eq isSigma1?'(M, OPDS, (T, NTL)) = isSigma1?'(M, OPDS, T) and-then isSigma1?'(M, OPDS, NTL) . op sigma1Top? : Module Term -> Bool . eq sigma1Top?(M, T) = sigma1Top?'(M, getOps(sigma1(M)), T) . op sigma1Top?' : Module OpDeclSet Term -> Bool . eq sigma1Top?'(M, OPDS, V) = true . ceq sigma1Top?'(M, (op F : nil -> TY [ ATS ] .) OPDS, C) = true if getName(C) == F and-then getType(C) == TY . eq sigma1Top?'(M, OPDS, C) = false [ owise ] . ceq sigma1Top?'(M, (op F : NTYL -> TY [ ATS ] .) OPDS, F[NTL]) = true if SB := metaMatch(M, F[fresh("NuITP-S1",NTYL, 0)], F[NTL], nil, 0) . eq sigma1Top?'(M, OPDS, F[NTL]) = false [ owise ] . op getMaxNotSigma1 : Module Term -> TermSet . eq getMaxNotSigma1(M, V) = mt . eq getMaxNotSigma1(M, C) = if sigma1Top?(M, C) then mt else C fi . eq getMaxNotSigma1(M, F[NTL]) = if sigma1Top?(M, F[NTL]) then getMaxNotSigma1(M, NTL) else F[NTL] fi . eq getMaxNotSigma1(M, (T,NTL)) = getMaxNotSigma1(M, T) ;; getMaxNotSigma1(M, NTL) . op toSub : Module String TermSet Nat -> Substitution . eq toSub(M, STR, mt, N) = none . eq toSub(M, STR, T, N) = fresh(STR, leastSort(M, T), N) <- T . eq toSub(M, STR, T ;; NTS, N) = toSub(M, STR, T, N) ; toSub(M, STR, NTS, N + 1) . op replaceMaxNotSigma1 : Term Substitution -> Term . eq replaceMaxNotSigma1(T, none) = T . eq replaceMaxNotSigma1(C, V <- C ; SB) = V . eq replaceMaxNotSigma1(C, SB) = C [ owise ] . eq replaceMaxNotSigma1(V, SB) = V . eq replaceMaxNotSigma1(F[NTL], V <- F[NTL] ; SB) = V . eq replaceMaxNotSigma1(F[NTL], SB) = F[replaceMaxNotSigma1(NTL, SB)] [ owise ] . eq replaceMaxNotSigma1((T,NTL), SB) = (replaceMaxNotSigma1(T, SB) , replaceMaxNotSigma1(NTL, SB)) . op reduceSet : Module TermSet -> TermSet . eq reduceSet(M, mt) = mt . eq reduceSet(M, T) = getTerm(metaReduce(M, T)) . eq reduceSet(M, T ;; NTS) = getTerm(metaReduce(M, T)) ;; reduceSet(M, NTS) . op split : TermSet -> TermSet . eq split(mt) = mt . eq split('_->_[GAMMA,'_/\_[NTL]]) = split'(GAMMA, NTL) . eq split(T) = T [ owise ] . eq split(T ;; NTS) = split(T) ;; split(NTS) . op split' : Term TermList -> TermSet . eq split'(GAMMA, empty) = mt . eq split'(GAMMA, T) = '_->_[GAMMA, T] . eq split'(GAMMA, (T,NTL)) = ('_->_[GAMMA, T]) ;; split'(GAMMA, NTL) . op unwrapAndCC : TermList -> TermSet . op unwrapAndCC : Term -> TermSet . eq unwrapAndCC((T,NTL)) = T ;; unwrapAndCC(NTL) . eq unwrapAndCC('_/\_[T,NTL]) = T ;; unwrapAndCC(NTL) . eq unwrapAndCC(T) = T [ owise ] . op wrapAndCC : TermSet -> Term . eq wrapAndCC(mt) = mt . eq wrapAndCC(NTS) = wrapAndCC'(NTS,empty) . op wrapAndCC' : TermSet TermList -> Term . eq wrapAndCC'(('_->_['true.NuITP-Bool,GAMMA]), empty) = GAMMA . eq wrapAndCC'(('_->_['true.NuITP-Bool,GAMMA]), NTL) = '_/\_[NTL,GAMMA] [ owise ] . eq wrapAndCC'((('_->_['true.NuITP-Bool,GAMMA]) ;; NTS), TL) = wrapAndCC'(NTS, (TL,GAMMA)) . op wrapAnd : TermList -> Term . eq wrapAnd(empty) = 'true.NuITP-Bool . eq wrapAnd(T) = T . eq wrapAnd((T,T',TL)) = '_/\_[T,T',TL] . op wrapCond : Term -> Term . eq wrapCond('_=_[LHS,RHS]) = '_->_['true.NuITP-Bool,'_=_[LHS,RHS]] . eq wrapCond('_=>_[LHS,RHS]) = '_->_['true.NuITP-Bool,'_=>_[LHS,RHS]] . eq wrapCond(T) = T [ owise ] . op toDNF : Module Term -> Term . eq toDNF(M, T) = getTerm(metaReduce(setEqs(M, getEqs(upModule('NuITP-DNF,false))), T)) . op toCNF : Module Term -> Term . eq toCNF(M, T) = getTerm(metaReduce(setEqs(M, getEqs(upModule('NuITP-CNF,false))), T)) . endfm fmod NuITP-STATE is pr NuITP-UTILS . sort Module? . subsort Module < Module? . sorts Goal GoalSet State . subsort Bool < Goal < GoalSet . var M : Module . vars V V' : Variable . var C : Constant . var NTL : NeTermList . vars TL TL' TL'' TL''' : TermList . var N : Nat . var B : Bool . vars CLA T T' T1 T2 T3 T4 T5 GAMMA DELTA LHS RHS : Term . vars SKO HPS : TermSet . var NTS : NeTermSet . vars ID ID' STR STR' : String . var G : Goal . vars GS GS' : GoalSet . vars QL QL' : QidList . var NeQL : NeQidList . vars Q F RID : Qid . vars LOG STRL STRL' : StringList . --- Id, SkolemOps, Hypotheses, Clause op {_,_,_,_,_} : String Qid TermSet TermSet Term -> Goal [ ctor ] . op mt : -> GoalSet [ ctor ] . op __ : GoalSet GoalSet -> GoalSet [ assoc comm id: mt ] . eq G:Goal G:Goal = G:Goal . op error : -> Module? [ ctor ] . ops empty sat unsat error : -> State [ ctor ] . op _|_|_|_ : Module StringList GoalSet GoalSet -> State . --- Closed goals are automatically removed from the frontier eq M | LOG | GS | { ID, RID, SKO, HPS, 'true.NuITP-Bool } GS' = M | LOG | GS { ID, RID, SKO, HPS, 'true.NuITP-Bool } | GS' . eq M | LOG | GS | { ID, RID, SKO, HPS, 'false.NuITP-Bool } GS' = M | LOG | GS { ID, RID, SKO, HPS, 'false.NuITP-Bool } | GS' . op getModule : State -> Module . eq getModule(M | LOG | GS | GS') = M . op getModule : Term -> Module . eq getModule('_|_|_|_[T, T1, T2, T3]) = downTerm(T, (error).Module?) . op getLog : State -> String . eq getLog(M | LOG | GS | GS') = join(LOG, true) . op getLog : Term -> String . eq getLog('_|_|_|_[T, T1, T2, T3]) = join(downTerm(T1, (nil).StringList), true) . op getMinLog : State -> String . eq getMinLog(M | LOG | GS | GS') = join(cleanLog(LOG, nil), false) . --- Call from saveReport op getMinLog : Term -> String . eq getMinLog('_|_|_|_[T, T1, T2, T3]) = join(cleanLog(downTerm(T1, (nil).StringList), nil), false) . --- Call from getReport op getMinLog : StringList -> String . eq getMinLog(LOG) = join(cleanLog(LOG, nil), false) . op addLog : Term String -> Term . eq addLog('_|_|_|_[T, T1, T2, T3], STR) = '_|_|_|_[T,addLog(T1, STR),T2, T3] . op addLog : Term String -> Term . eq addLog(T, "") = T . eq addLog(T, STR) = upTerm(downTerm(T, (nil).StringList) STR) [ owise ] . op join : StringList Bool -> String . eq join(nil, B) = "" . eq join(STR LOG, true) = " " + STR + join(LOG, true) . eq join(STR LOG, false) = STR + join(LOG, false) . op cleanLog : StringList StringList -> StringList . eq cleanLog(nil, STRL) = STRL . eq cleanLog(STR STRL, STRL') = if (substr(STR, 0, 5) == "undo ") then cleanLog(STRL, cleanLog'(STRL', substr(substr(STR, 5, length(STR)), 0, find(substr(STR, 5, length(STR)), " ", 0)))) else cleanLog(STRL, STRL' STR) fi . op cleanLog' : StringList String -> StringList . eq cleanLog'(nil, ID) = nil . eq cleanLog'(STR STRL, ID) = if (substr(STR, 0, 6) == "apply ") and-then ((ID == substr(substr(STR, find(STR, "to ", 0) + 3, length(STR)), 0, find(substr(STR, find(STR, "to ", 0) + 3, length(STR)), " ", 0))) or-else isPreffix(ID, substr(substr(STR, find(STR, "to ", 0) + 3, length(STR)), 0, find(substr(STR, find(STR, "to ", 0) + 3, length(STR)), " ", 0)))) then cleanLog'(STRL, ID) else STR cleanLog'(STRL, ID) fi . op getGID : Qid -> String . eq getGID(Q) = substr(string(getName(Q)), 1, length(string(getName(Q)))) . op getGoalRule : Goal -> Qid . eq getGoalRule({ ID, RID, SKO, HPS, CLA }) = RID . op getGoal : Term Qid -> GoalSet . eq getGoal(T, Q) = getGoal(downTerm(T, (error).State), substr(string(getName(Q)), 1, length(string(getName(Q))))) . op getGoal : Term String -> GoalSet . eq getGoal(T, ID) = getGoal(downTerm(T, (error).State), ID) . op getGoal : State String -> GoalSet . eq getGoal(M | LOG | { ID, RID, SKO, HPS, CLA } GS | GS', ID) = { ID, RID, SKO, HPS, CLA } . eq getGoal(M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS', ID) = { ID, RID, SKO, HPS, CLA } . eq getGoal(M | LOG | GS | GS', ID) = mt [ owise ] . op getAllGoals : Term -> GoalSet . eq getAllGoals(T) = getAllGoals(downTerm(T, (error).State)) . op getAllGoals : State -> GoalSet . eq getAllGoals(M | LOG | GS | GS') = GS GS' . eq getAllGoals(S:State) = mt [ owise ] . op getFrontier : Term -> GoalSet . eq getFrontier(T) = getFrontier(downTerm(T, (error).State)) . op getFrontier : State -> GoalSet . eq getFrontier(M | LOG | GS | GS') = GS' . eq getFrontier(S:State) = mt [ owise ] . op getProved : GoalSet -> GoalSet . eq getProved({ ID, RID, SKO, HPS, 'true.NuITP-Bool } GS) = { ID, RID, SKO, HPS, 'true.NuITP-Bool } getProved(GS) . eq getProved(GS) = mt [ owise ] . op removeProved : GoalSet -> GoalSet . eq removeProved({ ID, RID, SKO, HPS, 'true.NuITP-Bool } GS) = removeProved(GS) . eq removeProved(GS) = GS [ owise ] . op isGoal : Term -> Bool . eq isGoal(getTerm(noParse(N))) = false . eq isGoal(T) = true [ owise ] . op isGoal : Term Qid -> Bool . eq isGoal(T, Q) = isGoal(T, substr(string(getName(Q)), 1, length(string(getName(Q))))) . op isGoal : Term String -> Bool . eq isGoal(T, ID) = isGoal(downTerm(T, (error).State), ID) . op isGoal : State String -> Bool . eq isGoal(M | LOG | { ID, RID, SKO, HPS, CLA } GS | GS', ID) = true . eq isGoal(M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS', ID) = true . eq isGoal(M | LOG | GS | GS', ID) = false [ owise ] . op isFrontier : Term String -> GoalSet . eq isFrontier(T, ID) = isFrontier(downTerm(T, (error).State), ID) . op isFrontier : State String -> Bool . eq isFrontier(M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS', ID) = true . eq isFrontier(M | LOG | GS | GS', ID) = false [ owise ] . op removeGoals : GoalSet GoalSet -> GoalSet . eq removeGoals({ ID, RID, SKO, HPS, CLA } GS, { ID, RID, SKO, HPS, CLA } GS') = removeGoals(GS,GS') . eq removeGoals(GS, GS') = GS' [ owise ] . op getChildren : GoalSet String -> GoalSet . ceq getChildren({ ID, RID, SKO, HPS, CLA } GS, ID') = { ID, RID, SKO, HPS, CLA } getChildren(GS,ID') if isPreffix(ID', ID) . eq getChildren(GS, ID) = mt [ owise ] . op getChildren : Term String -> GoalSet . eq getChildren(T, ID) = getChildren(downTerm(T, (error).State), ID) . op getChildren : State String -> GoalSet . ceq getChildren(M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS', ID') = { ID, RID, SKO, HPS, CLA } getChildren(M | LOG | GS | GS', ID') if isPreffix(ID', ID) . ceq getChildren(M | LOG | { ID, RID, SKO, HPS, CLA } GS | GS', ID') = { ID, RID, SKO, HPS, CLA } getChildren(M | LOG | GS | GS', ID') if isPreffix(ID', ID) . eq getChildren(M | LOG | GS | GS', ID') = mt [ owise ] . op isPreffix : String String -> Bool . eq isPreffix(STR, STR) = false . eq isPreffix(STR, STR') = (substr(STR', 0, length(STR)) == STR) and-then (substr(STR', length(STR), 1) == ".") [ owise ] . op isProved : Goal -> Bool . eq isProved({ ID, RID, SKO, HPS, CLA }) = (CLA == 'true.NuITP-Bool) or-else (CLA == 'false.NuITP-Bool) . op size : GoalSet -> Nat . eq size((mt).GoalSet) = 0 . eq size(G GS) = 1 + size(GS) . op getClause : Term String -> Term . eq getClause(T, ID) = getClause(downTerm(T, (error).State), ID) . op getClause : State String -> TermSet . eq getClause(M | LOG | { ID, RID, SKO, HPS, CLA } GS | GS', ID) = CLA . eq getClause(M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS', ID) = CLA . eq getClause(M | LOG | GS | GS', ID) = mt [ owise ] . op getSkolemOps : Term String -> OpDeclSet . eq getSkolemOps(T, ID) = getSkolemOps'(downTerm(T, (error).State), ID) . op getSkolemOps' : State String -> OpDeclSet . eq getSkolemOps'(M | LOG | { ID, RID, SKO, HPS, CLA } GS | GS', ID) = toOps(SKO) . eq getSkolemOps'(M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS', ID) = toOps(SKO) . eq getSkolemOps'(M | LOG | GS | GS', ID) = none [ owise ] . op deleteGoal : Term String -> Term . eq deleteGoal(T, ID) = upTerm(deleteGoal(downTerm(T, (error).State), ID)) . op deleteGoal : State String -> State . ceq deleteGoal(M | LOG | { ID, RID, SKO, HPS, CLA } GS | GS', ID) = deleteGoal(M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS', ID) if (CLA =/= 'true.NuITP-Bool) . ceq deleteGoal(M | LOG | { ID, RID, SKO, HPS, CLA } GS | GS', ID') = deleteGoal(M | LOG | GS | GS', ID') if isPreffix(ID', ID) . ceq deleteGoal(M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS', ID') = deleteGoal(M | LOG | GS | GS', ID') if isPreffix(ID', ID) . eq deleteGoal(M | LOG | GS | GS', ID) = M | LOG "undo " + ID + " .\n" | GS | GS' [ owise ] . endfm fmod NuITP-REMOVE-U is pr NuITP-UTILS . vars Q F : Qid . var IL : ImportList . var SS : SortSet . var SSDS : SubsortDeclSet . var OPDS : OpDeclSet . var MAS : MembAxSet . vars EQS EQS' EQS'' : EquationSet . var RLS : RuleSet . var STDS : StratDeclSet . var STDFS : StratDefSet . vars TY TY' TY'' : Type . var ATS : AttrSet . vars T LHS RHS : Term . var M : Module . vars EQ EQ' : Equation . var N : Nat . var SB : Substitution . var P : Parent . var B : Bool . --- Only for flat modules op removeU : Module -> Module . eq removeU(fmod Q is IL sorts SS . SSDS OPDS MAS EQS endfm) = removeU'(fmod Q is IL sorts SS . SSDS getOps(removeU(fmod Q is IL sorts SS . SSDS OPDS MAS EQS endfm, OPDS)) MAS getEqs(removeU(fmod Q is IL sorts SS . SSDS OPDS MAS EQS endfm, OPDS)) endfm, EQS) . eq removeU(fth Q is IL sorts SS . SSDS OPDS MAS EQS endfth) = removeU'(fth Q is IL sorts SS . SSDS getOps(removeU(fth Q is IL sorts SS . SSDS OPDS MAS EQS endfth, OPDS)) MAS getEqs(removeU(fth Q is IL sorts SS . SSDS OPDS MAS EQS endfth, OPDS)) endfth, EQS) . eq removeU(mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS endm) = removeU'(mod Q is IL sorts SS . SSDS getOps(removeU(mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS endm, OPDS)) MAS getEqs(removeU(mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS endm, OPDS)) RLS endm, EQS) . eq removeU(th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth) = removeU'(th Q is IL sorts SS . SSDS getOps(removeU(th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth, OPDS)) MAS getEqs(removeU(th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth, OPDS)) RLS endth, EQS) . eq removeU(smod Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm) = removeU'(smod Q is IL sorts SS . SSDS getOps(removeU(smod Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm, OPDS)) MAS getEqs(removeU(smod Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm, OPDS)) RLS STDS STDFS endsm, EQS) . eq removeU(sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth) = removeU'(sth Q is IL sorts SS . SSDS getOps(removeU(sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth, OPDS)) MAS getEqs(removeU(sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth, OPDS)) RLS STDS STDFS endsth, EQS) . op removeU : Module OpDeclSet -> ResultPair . eq removeU(M, OPDS) = removeU(M, { OPDS , none }) . op removeU : Module ResultPair -> ResultPair . eq removeU(M, { (op F : TY TY' -> TY'' [ id(T) ATS ] .) OPDS , EQS }) = removeU(M, { (op F : TY TY' -> TY'' [ ATS ] .) OPDS, EQS (eq F[T,qid("NuITP-RU:" + string(getKind(M,TY)))] = qid("NuITP-RU:" + string(getKind(M,TY))) [ variant ] .) if (not comm in ATS) then (eq F[qid("NuITP-RU-:" + string(getKind(M,TY))),T] = qid("NuITP-RU-:" + string(getKind(M,TY))) [ variant ] .) else none fi if (assoc in ATS) then (eq F[qid("NuITP-RU1:" + string(getKind(M,TY))), T, qid("NuITP-RU2:" + string(getKind(M,TY)))] = F[qid("NuITP-RU1:" + string(getKind(M,TY))), qid("NuITP-RU2:" + string(getKind(M,TY)))] [ variant ] .) else none fi }) . eq removeU(M, { (op F : TY TY' -> TY'' [ left-id(T) ATS ] .) OPDS , EQS }) = removeU(M, { (op F : TY TY' -> TY'' [ ATS ] .) OPDS, EQS (eq F[T,qid("NuITP-RU:" + string(getKind(M,TY)))] = qid("NuITP-RU:" + string(getKind(M,TY))) [ variant ] .) if (assoc in ATS) then (eq F[qid("NuITP-RU1:" + string(getKind(M,TY))), T, qid("NuITP-RU2:" + string(getKind(M,TY)))] = F[qid("NuITP-RU1:" + string(getKind(M,TY))), qid("NuITP-RU2:" + string(getKind(M,TY)))] [ variant ] .) else none fi }) . eq removeU(M, { (op F : TY TY' -> TY'' [ right-id(T) ATS ] .) OPDS , EQS }) = removeU(M, { (op F : TY TY' -> TY'' [ ATS ] .) OPDS, EQS (eq F[qid("NuITP-RU:" + string(getKind(M,TY))),T] = qid("NuITP-RU:" + string(getKind(M,TY))) [ variant ] .) if (assoc in ATS) then (eq F[qid("NuITP-RU1:" + string(getKind(M,TY))), T, qid("NuITP-RU2:" + string(getKind(M,TY)))] = F[qid("NuITP-RU1:" + string(getKind(M,TY))), qid("NuITP-RU2:" + string(getKind(M,TY)))] [ variant ] .) else none fi }) . eq removeU(M, { OPDS , EQS }) = { OPDS , EQS } [ owise ] . op removeU' : Module EquationSet -> Module . eq removeU'(M, none) = M . eq removeU'(fmod Q is IL sorts SS . SSDS OPDS MAS EQS endfm, EQ EQS') = fmod Q is IL sorts SS . SSDS OPDS MAS removeU'(fmod Q is IL sorts SS . SSDS OPDS MAS EQS endfm, EQ, EQS', 0, none) endfm . eq removeU'(fth Q is IL sorts SS . SSDS OPDS MAS EQS endfth, EQ EQS') = fth Q is IL sorts SS . SSDS OPDS MAS removeU'(fth Q is IL sorts SS . SSDS OPDS MAS EQS endfth, EQ, EQS', 0, none) endfth . eq removeU'(mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS endm, EQ EQS') = mod Q is IL sorts SS . SSDS OPDS MAS removeU'(mod Q is IL sorts SS . SSDS OPDS MAS EQS RLS endm, EQ, EQS', 0, none) RLS endm . eq removeU'(th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth, EQ EQS') = th Q is IL sorts SS . SSDS OPDS MAS removeU'(th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth, EQ, EQS', 0, none) RLS endth . eq removeU'(smod Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm, EQ EQS') = smod Q is IL sorts SS . SSDS OPDS MAS removeU'(smod Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm, EQ, EQS', 0, none) RLS STDS STDFS endsm . eq removeU'(sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth, EQ EQS') = sth Q is IL sorts SS . SSDS OPDS MAS removeU'(sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth, EQ, EQS', 0, none) RLS STDS STDFS endsth . op removeU' : Module Equation EquationSet Nat EquationSet -> EquationSet . --- TODO: Conditional? ceq removeU'(M, (eq LHS = RHS [ ATS ] .), EQS, N, EQS') = removeU'(M, (eq LHS = RHS [ ATS ] .), EQS, s(N), EQS' if (T =/= applySub(RHS,SB)) then safeVars((eq T = applySub(RHS,SB) [ ATS ] .),"NuITP-RU-") else none fi) if { T, SB, F, P, B } := metaGetVariant(M, LHS, empty, '#, N) . eq removeU'(M, EQ, EQ' EQS', N, EQS'') = removeU'(M, EQ', EQS', 1, EQS'' (if (N == 1) then EQ else none fi)) [ owise ] . eq removeU'(M, EQ, none, N, EQS) = EQS (if (N == 1) then EQ else none fi) [ owise ] . endfm fmod NuITP-EQPREDS is pr NuITP-UTILS . var M : Module . var N : Nat . var K : Kind . var KS : KindSet . vars B B' : Bool . vars S S' TOP : Sort . vars SS SS' : SortSet . var NeSS : NeSortSet . var SSDS : SubsortDeclSet . vars TY TY' TY'' : Type . vars TYL TYL' : TypeList . vars NeTYL NeTYL' : NeTypeList . vars ATS ATS' : AttrSet . vars F F' : Qid . var OP : OpDecl . vars OPDS OPDS' : OpDeclSet . var EQS : EquationSet . vars T T' T'' T1 T2 T3 T4 : Term . vars TL TL' TL'' TL1 TL2 : TermList . var NeHL : NeHookList . --- Requires module with NuITP-BOOL/CLAUSE extension op eqPreds : Module -> Module [memo] . eq eqPreds(M) = eqPreds-step2(eqPreds-step1(M, getKinds(M), 0, none, none, none), maximalOps(M, getOps(M)), none) . op eqPreds-step1 : Module KindSet Nat SortSet SubsortDeclSet OpDeclSet -> Module . eq eqPreds-step1(M, none, N, SS, SSDS, OPDS) = addOps(addOps(addSubSorts(addSorts(M, SS), SSDS), OPDS), eqPreds-step1''(addSubSorts(addSorts(M, SS), SSDS), getOps(M), none)) . eq eqPreds-step1(M, K ; KS, N, SS, SSDS, OPDS) = eqPreds-step1(M, KS, s(N), SS ; getSorts(eqPreds-step1'(M, maximalSorts(M, K), N, none, none)), SSDS getSubsorts(eqPreds-step1'(M, maximalSorts(M, K), N, none, none)), OPDS getOps(eqPreds-step1'(M, maximalSorts(M, K), N, none, none))) . op eqPreds-step1' : Module SortSet Nat SortSet SubsortDeclSet -> ResultTriple . eq eqPreds-step1'(M, S, N, none, none) = { none, none, (op '_=_ : S S -> 'Eq [ comm ] .) } . eq eqPreds-step1'(M, S, N, SS, SSDS) = { SS ; qid("NuITP-TOP-" + string(N, 10)), SSDS (subsort S < qid("NuITP-TOP-" + string(N, 10)) .), (op '_=_ : qid("NuITP-TOP-" + string(N, 10)) qid("NuITP-TOP-" + string(N, 10)) -> 'Eq [ comm ] .) } [ owise ] . eq eqPreds-step1'(M, S ; NeSS, N, SS, SSDS) = eqPreds-step1'(M, NeSS, N, SS ; qid("NuITP-TOP-" + string(N, 10)), SSDS (subsort S < qid("NuITP-TOP-" + string(N, 10)) .)) . op eqPreds-step1'' : Module OpDeclSet OpDeclSet -> OpDeclSet . eq eqPreds-step1''(M, (op F : TY TY' -> TY'' [ assoc ATS ] .) OPDS, OPDS') = eqPreds-step1''(M, OPDS, OPDS' (op qid("NuITP-ROOT-" + safeString(F)) : maximalSorts(M, getKind(M, TY'')) -> 'NuITP-Bool [none] .) (op qid("NuITP-IN-" + safeString(F)) : maximalSorts(M, getKind(M, TY'')) maximalSorts(M, getKind(M, TY'')) -> 'NuITP-Bool [none] .)) . eq eqPreds-step1''(M, OPDS, OPDS') = OPDS' [ owise ] . op isMaximal : Module TypeList TypeList -> Bool . eq isMaximal(M, TY TYL, TY' TYL') = not(TY in TY' lesserSorts(M, TY')) or-else isMaximal(M, TYL, TYL') . eq isMaximal(M, TYL, TYL') = false [ owise ] . op maximalOps : Module OpDeclSet -> OpDeclSet . ceq maximalOps(M, (op F : TYL -> TY [ ATS ] .) OPDS) = maximalOps(M, OPDS) if not(ctor in ATS) . ceq maximalOps(M, (op F : TYL -> TY [ ctor ATS ] .) (op F : TYL' -> TY' [ ctor ATS' ] .) OPDS) = maximalOps(M, (op F : TYL' -> TY' [ ctor ATS' ] .) OPDS) if isMaximal(M, TYL TY, TYL' TY) . eq maximalOps(M, OPDS) = OPDS [ owise ] . op eqPreds-step2 : Module OpDeclSet EquationSet -> Module . eq eqPreds-step2(M, none, EQS) = addEqs(M, EQS eqPreds-step2'(M, getKinds(M), none)) . eq eqPreds-step2(M, (op '_=_ : 'Universal 'Universal -> 'Eq [ ATS ] .) OPDS, EQS) = eqPreds-step2(M, OPDS, EQS) . eq eqPreds-step2(M, (op '_=>_ : 'Universal 'Universal -> 'Rl [ ATS ] .) OPDS, EQS) = eqPreds-step2(M, OPDS, EQS) . eq eqPreds-step2(M, (op F : TYL -> TY [ ATS ] .) OPDS, EQS) = eqPreds-step2(M, OPDS, EQS eqPreds-step2'(M, (op F : TYL -> TY [ ATS ] .), OPDS, assoc in ATS, comm in ATS)) [ owise ] . op eqPreds-step2' : Module KindSet EquationSet -> EquationSet . eq eqPreds-step2'(M, none, EQS) = EQS . eq eqPreds-step2'(M, '`[NuITP-Bool`] ; KS, EQS) = eqPreds-step2'(M, KS, EQS) . eq eqPreds-step2'(M, K ; KS, EQS) = eqPreds-step2'(M, KS, EQS (eq '_=_[fresh("NuITP-AUX-", maximalSorts(M, K)), fresh("NuITP-AUX-", maximalSorts(M, K))] = 'true.NuITP-Bool [none] .)) [ owise ] . op eqPreds-step2' : Module OpDecl OpDeclSet Bool Bool -> EquationSet . eq eqPreds-step2'(M, (op F : nil -> TY [ ATS ] .), OPDS, false, false) = eqPreds-step2Other(M, (op F : nil -> TY [ ATS ] .), OPDS, false, none) . --- Free, arity = 0 eq eqPreds-step2'(M, (op F : TYL -> TY [ ATS ] .), OPDS, false, false) = --- Free, arity > 0 --- Other eqPreds-step2Other(M, (op F : TYL -> TY [ ATS ] .), OPDS, false, none) --- Itself (eq '_=_[F[fresh("NuITP-AUX1-", TYL, 0)], F[fresh("NuITP-AUX2-", TYL, 0)]] = eqPreds-step2ItselfFree(fresh("NuITP-AUX1-", TYL, 0), fresh("NuITP-AUX2-", TYL, 0), empty) [none] .) --- Each eqPreds-step2EachFree(M, F[fresh("NuITP-AUX-", TYL, 0)], fresh("NuITP-AUX-", TYL, 0), none) [ owise ] . eq eqPreds-step2'(M, (op F : TY TY -> TY' [ ATS ] .), OPDS, false, true) = --- C --- Other eqPreds-step2Other(M, (op F : TY TY -> TY' [ ATS ] .), OPDS, false, none) --- Itself (eq '_=_[F[fresh("NuITP-AUX1", TY), fresh("NuITP-AUX2", TY)], F[fresh("NuITP-AUX3", TY), fresh("NuITP-AUX4", TY)]] = '_\/_['_/\_['_=_[fresh("NuITP-AUX1", TY), fresh("NuITP-AUX3", TY)], '_=_[fresh("NuITP-AUX2", TY), fresh("NuITP-AUX4", TY)]], '_/\_['_=_[fresh("NuITP-AUX1", TY), fresh("NuITP-AUX4", TY)], '_=_[fresh("NuITP-AUX2", TY), fresh("NuITP-AUX3", TY)]]] [none] .) --- and if (sameKind(M, TY, TY')) then (eq '_=_[F[fresh("NuITP-AUX1", TY), fresh("NuITP-AUX2", TY)], fresh("NuITP-AUX1", TY)] = 'false.NuITP-Bool [none] .) else none fi . eq eqPreds-step2'(M, (op F : TY TY' -> TY'' [ ATS ] .), OPDS, true, false) = --- A --- Itself (eq qid("NuITP-ROOT-" + safeString(F))[F[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX2", TY'')]] = 'true.NuITP-Bool [none] .) --- Other eqPreds-step2Other(M, (op F : TY TY' -> TY'' [ ATS ] .), OPDS, true, none) --- Itself (2) (eq '_=_[F[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX2", TY'')], F[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX4", TY'')]] = '_=_[fresh("NuITP-AUX2", TY''), fresh("NuITP-AUX4", TY'')] [none] .) (eq '_=_[F[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX2", TY'')], F[fresh("NuITP-AUX3", TY''), fresh("NuITP-AUX2", TY'')]] = '_=_[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX3", TY'')] [none] .) (ceq '_=_[F[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX2", TY'')], F[fresh("NuITP-AUX3", TY''), fresh("NuITP-AUX4", TY'')]] = 'false.NuITP-Bool if qid("NuITP-ROOT-" + safeString(F))[fresh("NuITP-AUX1", TY'')] = 'true.NuITP-Bool /\ qid("NuITP-ROOT-" + safeString(F))[fresh("NuITP-AUX3", TY'')] = 'true.NuITP-Bool /\ '_=_[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX3", TY'')] = 'true.NuITP-Bool [none] .) --- Each (eq '_=_[F[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX2", TY'')], fresh("NuITP-AUX1", TY'')] = 'false.NuITP-Bool [none] .) (eq '_=_[F[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX2", TY'')], fresh("NuITP-AUX2", TY'')] = 'false.NuITP-Bool [none] .) . eq eqPreds-step2'(M, (op F : TY TY' -> TY'' [ ATS ] .), OPDS, true, true) = --- AC --- Itself (1) (eq qid("NuITP-ROOT-" + safeString(F))[F[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX2", TY'')]] = 'true.NuITP-Bool [none] .) --- Other eqPreds-step2Other(M, (op F : TY TY' -> TY'' [ ATS ] .), OPDS, true, none) --- Itself (2) (ceq qid("NuITP-IN-" + safeString(F))[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX2", getKind(M, TY''))] = 'false.NuITP-Bool if qid("NuITP-ROOT-" + safeString(F))[fresh("NuITP-AUX1", TY'')] = 'true.NuITP-Bool [none] .) (ceq qid("NuITP-IN-" + safeString(F))[fresh("NuITP-AUX1", TY''), F[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX2", TY'')]] = 'true.NuITP-Bool if 'not_[qid("NuITP-ROOT-" + safeString(F))[fresh("NuITP-AUX1", TY'')]] = 'true.NuITP-Bool [none] .) (ceq qid("NuITP-IN-" + safeString(F))[fresh("NuITP-AUX", getKind(M, TY'')), F[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX2", TY'')]] = '_\/_['_=_[fresh("NuITP-AUX", getKind(M, TY'')), fresh("NuITP-AUX1", TY'')], qid("NuITP-IN-" + safeString(F))[fresh("NuITP-AUX", getKind(M, TY'')), fresh("NuITP-AUX2", TY'')]] if 'not_[qid("NuITP-ROOT-" + safeString(F))[fresh("NuITP-AUX", getKind(M, TY''))]] = 'true.NuITP-Bool /\ 'not_[qid("NuITP-ROOT-" + safeString(F))[fresh("NuITP-AUX1", TY'')]] = 'true.NuITP-Bool [none] .) (ceq qid("NuITP-IN-" + safeString(F))[fresh("NuITP-AUX1", getKind(M, TY'')), fresh("NuITP-AUX2", getKind(M, TY''))] = '_=_[fresh("NuITP-AUX1", getKind(M, TY'')), fresh("NuITP-AUX2", getKind(M, TY''))] if 'not_[qid("NuITP-ROOT-" + safeString(F))[fresh("NuITP-AUX1", getKind(M, TY''))]] = 'true.NuITP-Bool /\ 'not_[qid("NuITP-ROOT-" + safeString(F))[fresh("NuITP-AUX2", getKind(M, TY''))]] = 'true.NuITP-Bool [none] .) --- and (1) (eq '_=_[F[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX2", TY'')], F[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX4", TY'')]] = '_=_[fresh("NuITP-AUX2", TY''), fresh("NuITP-AUX4", TY'')] [none] .) (ceq '_=_[F[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX2", TY'')], F[fresh("NuITP-AUX3", TY''), fresh("NuITP-AUX4", TY'')]] = 'false.NuITP-Bool if 'not_[qid("NuITP-ROOT-" + safeString(F))[fresh("NuITP-AUX1", TY'')]] = 'true.NuITP-Bool /\ 'not_[qid("NuITP-IN-" + safeString(F))[fresh("NuITP-AUX1", TY''), F[fresh("NuITP-AUX3", TY''), fresh("NuITP-AUX4", TY'')]]] = 'true.NuITP-Bool [none] .) --- and (2) (eq '_=_[F[fresh("NuITP-AUX1", TY''), fresh("NuITP-AUX2", TY'')], fresh("NuITP-AUX1", TY'')] = 'false.NuITP-Bool [none] .) . op eqPreds-step2Other : Module OpDecl OpDeclSet Bool EquationSet -> EquationSet . eq eqPreds-step2Other(M, (op F : TYL -> TY [ ATS ] .), none, B, EQS) = EQS . eq eqPreds-step2Other(M, (op F : TYL -> TY [ ATS ] .), (op F : TYL' -> TY' [ ATS' ] .) OPDS, B, EQS) = eqPreds-step2Other(M, (op F : TYL -> TY [ ATS ] .), OPDS, B, EQS) . eq eqPreds-step2Other(M, (op F : nil -> TY [ ATS ] .), (op F' : nil -> TY' [ ATS' ] .) OPDS, B, EQS) = if (sameKind(M, TY, TY')) then eqPreds-step2Other(M, (op F : nil -> TY [ ATS ] .), OPDS, B, EQS (eq '_=_[qid(string(F) + "." + string(TY)), qid(string(F') + "." + string(TY'))] = 'false.NuITP-Bool [none] .)) else eqPreds-step2Other(M, (op F : nil -> TY [ ATS ] .), OPDS, B, EQS) fi [ owise ] . eq eqPreds-step2Other(M, (op F : nil -> TY [ ATS ] .), (op F' : NeTYL -> TY' [ ATS' ] .) OPDS, B, EQS) = if (sameKind(M, TY, TY')) then eqPreds-step2Other(M, (op F : nil -> TY [ ATS ] .), OPDS, B, EQS (eq '_=_[qid(string(F) + "." + string(TY)), F'[fresh("NuITP-AUX2-", NeTYL, 0)]] = 'false.NuITP-Bool [none] .)) else eqPreds-step2Other(M, (op F : nil -> TY [ ATS ] .), OPDS, B, EQS) fi [ owise ] . eq eqPreds-step2Other(M, (op F : NeTYL -> TY [ ATS ] .), (op F' : nil -> TY' [ ATS' ] .) OPDS, B, EQS) = if (sameKind(M, TY, TY')) then if (B) --- A, AC then eqPreds-step2Other(M, (op F : NeTYL -> TY [ ATS ] .), OPDS, B, EQS (eq qid("NuITP-ROOT-" + safeString(F))[qid(string(F') + "." + string(TY))] = 'false.NuITP-Bool [none] .) (eq '_=_[F[fresh("NuITP-AUX1-", NeTYL, 0)], qid(string(F') + "." + string(TY))] = 'false.NuITP-Bool [none] .)) else eqPreds-step2Other(M, (op F : NeTYL -> TY [ ATS ] .), OPDS, B, EQS (eq '_=_[F[fresh("NuITP-AUX1-", NeTYL, 0)], qid(string(F') + "." + string(TY))] = 'false.NuITP-Bool [none] .)) fi else eqPreds-step2Other(M, (op F : NeTYL -> TY [ ATS ] .), OPDS, B, EQS) fi [ owise ] . eq eqPreds-step2Other(M, (op F : NeTYL -> TY [ ATS ] .), (op F' : NeTYL' -> TY' [ ATS' ] .) OPDS, B, EQS) = if (sameKind(M, TY, TY')) then if (B) --- A, AC then eqPreds-step2Other(M, (op F : NeTYL -> TY [ ATS ] .), OPDS, B, EQS (eq qid("NuITP-ROOT-" + safeString(F))[F'[fresh("NuITP-AUX-", NeTYL', 0)]] = 'false.NuITP-Bool [none] .) (eq '_=_[F[fresh("NuITP-AUX1-", NeTYL, 0)], F'[fresh("NuITP-AUX2-", NeTYL', 0)]] = 'false.NuITP-Bool [none] .)) else eqPreds-step2Other(M, (op F : NeTYL -> TY [ ATS ] .), OPDS, B, EQS (eq '_=_[F[fresh("NuITP-AUX1-", NeTYL, 0)], F'[fresh("NuITP-AUX2-", NeTYL', 0)]] = 'false.NuITP-Bool [none] .)) fi else eqPreds-step2Other(M, (op F : NeTYL -> TY [ ATS ] .), OPDS, B, EQS) fi [ owise ] . op eqPreds-step2ItselfFree : TermList TermList TermList -> Term . eq eqPreds-step2ItselfFree(empty, empty, T) = T . eq eqPreds-step2ItselfFree(empty, empty, TL) = '_/\_[TL] [ owise ] . eq eqPreds-step2ItselfFree((T1, TL1), (T2, TL2), TL) = eqPreds-step2ItselfFree(TL1, TL2, (TL, '_=_[T1, T2])) . op eqPreds-step2EachFree : Module Term TermList EquationSet -> EquationSet . eq eqPreds-step2EachFree(M, T, empty, EQS) = EQS . eq eqPreds-step2EachFree(M, T, (T', TL), EQS) = eqPreds-step2EachFree(M, T, TL, EQS if (sameKind(M, getType(metaReduce(M, T)), getType(metaReduce(M, T')))) then (eq '_=_[T, T'] = 'false.NuITP-Bool [none] .) else none fi) . endfm fmod NuITP-SKOLEM is pr NuITP-UTILS . var M : Module . var F : Qid . var V : Variable . vars C C' : Constant . var T : Term . var TS SKO : TermSet . var NTS : NeTermSet . var NTL : NeTermList . var NCTL : NeCTermList . var SB : Substitution . var CO : Context . op freeze : TermSet -> TermSet . eq freeze((mt).TermSet) = mt . eq freeze(C) = C . eq freeze(V) = qid(string(getName(V)) + "." + string(getType(V))) . eq freeze(F[NTL]) = F[freeze(NTL)] . eq freeze((T,NTL)) = (freeze(T),freeze(NTL)) . eq freeze(T ;; NTS) = freeze(T) ;; freeze(NTS) . op freeze : TermSet TermSet -> TermSet . eq freeze((mt).TermSet, TS) = mt . eq freeze(C, TS) = C . eq freeze(V, TS) = if (V in TS) then qid(string(getName(V)) + "." + string(getType(V))) else V fi . eq freeze(F[NTL], TS) = F[freeze(NTL,TS)] . eq freeze((T,NTL), TS) = (freeze(T,TS),freeze(NTL,TS)) . eq freeze(T ;; NTS, TS) = freeze(T,TS) ;; freeze(NTS,TS) . op freeze : Substitution -> Substitution . eq freeze((none).Substitution) = none . eq freeze(V <- T ; SB) = (V <- freeze(T)) ; freeze(SB) . op freeze : Substitution TermSet -> Substitution . eq freeze((none).Substitution,TS) = none . eq freeze(V <- T ; SB,TS) = (V <- freeze(T,TS)) ; freeze(SB,TS) . op unfreeze : Substitution -> Substitution . eq unfreeze((none).Substitution) = none . eq unfreeze(V <- T ; SB) = (V <- unfreeze(T)) ; unfreeze(SB) . op unfreeze : Substitution TermSet -> Substitution . eq unfreeze((none).Substitution,TS) = none . eq unfreeze(V <- T ; SB,TS) = (V <- unfreeze(T,TS)) ; unfreeze(SB,TS) . op unfreeze : TermList -> Variable . eq unfreeze(V) = V . eq unfreeze(C) = qid(string(getName(C)) + ":" + string(getType(C))) . eq unfreeze(F[NTL]) = F[unfreeze(NTL)] . eq unfreeze((T,NTL)) = (unfreeze(T),unfreeze(NTL)) . op unfreeze : Context TermSet -> Context . eq unfreeze(CO,mt) = CO . eq unfreeze(CO,C ;; NTS) = unfreeze(unfreeze(CO,C),NTS) . op unfreeze : Context Constant -> Context . eq unfreeze([],C) = [] . eq unfreeze(F[NCTL],C) = F[unfreeze(NCTL,C)] . eq unfreeze((T,NCTL),C) = unfreeze(T,C),unfreeze(NCTL,C) . eq unfreeze((CO,NTL),C) = unfreeze(CO,C),unfreeze(NTL,C) . op unfreeze : Term TermSet -> Term . eq unfreeze(T,mt) = T . eq unfreeze(T,C ;; NTS) = unfreeze(unfreeze(T,C),NTS) . op unfreeze : TermList Constant -> Term . eq unfreeze(empty,C) = empty . eq unfreeze(C,C') = if (C == C') then qid(string(getName(C)) + ":" + string(getType(C))) else C fi . eq unfreeze(V,C) = V . eq unfreeze(F[NTL],C) = F[unfreeze(NTL,C)] . eq unfreeze((T,NTL),C) = unfreeze(T,C),unfreeze(NTL,C) . op skolemSub : TermSet -> Substitution . eq skolemSub(mt) = none . eq skolemSub(V) = V <- freeze(V) . eq skolemSub(V ;; NTS) = V <- freeze(V) ; skolemSub(NTS) . op skvars : TermList TermSet -> TermSet . eq skvars(empty,SKO) = mt . eq skvars(C,C ;; SKO) = qid(string(getName(C)) + ":" + string(getType(C))) . eq skvars(C,SKO) = mt [ owise ] . eq skvars(V,SKO) = mt . eq skvars(F[NTL],SKO) = skvars(NTL,SKO) . eq skvars((T,NTL),SKO) = skvars(T,SKO) ;; skvars(NTL,SKO) . endfm -------------------------------------------------------------------------------- --- The following AAC-RPO code is a minimal, adapted version --- of the original AAC-RPO implemented by --- Raúl Gutiérrez -------------------------------------------------------------------------------- fmod NuITP-AAC-RPO is pr CONVERSION . pr META-LEVEL . sorts StringMap StringMapList . subsort StringMap < StringMapList . sorts NatOpDecl NatOpDeclList . subsort NatOpDecl < NatOpDeclList . sorts KindOpDeclSet KindOpDeclSetSet NEKindOpDeclSetSet . sorts EKindOpDeclSet EKindOpDeclSetSet NEEKindOpDeclSetSet . subsorts KindOpDeclSet < NEKindOpDeclSetSet < KindOpDeclSetSet . subsorts EKindOpDeclSet < NEEKindOpDeclSetSet < EKindOpDeclSetSet . op _::_ : Kind OpDeclSet -> KindOpDeclSet [ ctor ] . op none : -> KindOpDeclSetSet [ ctor ] . op __ : NEKindOpDeclSetSet NEKindOpDeclSetSet -> NEKindOpDeclSetSet [ ctor assoc comm id: none ] . op __ : KindOpDeclSetSet KindOpDeclSetSet -> KindOpDeclSetSet [ assoc comm id: none ] . op _[_]::_ : Type TypeList OpDeclSet -> EKindOpDeclSet [ ctor ] . op none : -> EKindOpDeclSetSet [ ctor ] . op __ : NEEKindOpDeclSetSet NEEKindOpDeclSetSet -> NEEKindOpDeclSetSet [ ctor assoc comm id: none ] . op __ : EKindOpDeclSetSet EKindOpDeclSetSet -> EKindOpDeclSetSet [ assoc comm id: none ] . op ((_,_)) : Nat OpDecl -> NatOpDecl [ ctor ] . op nil : -> NatOpDeclList [ ctor ] . op __ : NatOpDeclList NatOpDeclList -> NatOpDeclList [ ctor assoc id: nil ] . var M : Module . var H : Header . var IL : ImportList . var SS : SortSet . var SSDS : SubsortDeclSet . vars OPDS OPDS1 OPDS2 : OpDeclSet . var MAS : MembAxSet . var EQS : EquationSet . var RLS : RuleSet . vars T T1 T2 : Term . vars OPD OPD1 OPD2 : OpDecl . vars ATS ATS1 ATS2 : AttrSet . var B : Bool . var K : Kind . vars F F1 F2 : Qid . vars TY TY1 TY2 TY3 TYI1 TYI2 : Type . vars TYL TYL1 TYL2 TYL3 : TypeList . vars N N1 N2 : Nat . vars STR STR' STR'' : String . var SML : StringMapList . vars NOPD1 NOPD2 : NatOpDecl . vars NOPDL NOPDL1 NOPDL2 : NatOpDeclList . var KOPDS : KindOpDeclSetSet . var EKOPDS : EKindOpDeclSetSet . op [_,_] : String String -> StringMap [ ctor ] . op empty : -> StringMapList [ ctor ] . op __ : StringMapList StringMapList -> StringMapList [ ctor assoc id: empty ] . op sort : NatOpDeclList -> NatOpDeclList . ceq sort(NOPDL (( N1, OPD1 )) NOPDL1 (( N2 , OPD2 )) NOPDL2) = sort(NOPDL (( N2, OPD2 )) NOPDL1 (( N1 , OPD1 )) NOPDL2) if N2 < N1 . eq sort(NOPDL) = NOPDL [ owise ] . op replace : String String String -> String . eq replace(STR, STR', STR'') = replace(STR, STR', STR'', find(STR, STR', 0)) . op replace : String String String FindResult -> String . eq replace(STR, STR', STR'', notFound) = STR . eq replace(STR, STR', STR'', N) = substr(STR, 0, N) + STR'' + replace(substr(STR, N + length(STR'), length(STR)), STR', STR'') . op replaceAll : String StringMapList -> String . eq replaceAll(STR, empty) = STR . eq replaceAll(STR, [ STR' , STR'' ] SML) = replaceAll(replace(STR, STR', STR''), SML) . op alpha : String -> String . eq alpha(STR) = replaceAll(STR, [ "_" , "" ] [ "`," , "comma" ] [ "`[" , "lbracket" ] [ "`]" , "rbracket" ] [ "`(" , "lparen" ] [ "`)" , "rparen" ] [ "`{" , "lbrace" ] [ "`}" , "rbrace" ]) . op isCommSameKind : Module OpDecl -> Bool . eq isCommSameKind(M, (op F : TY1 TY2 -> TY [ comm ATS ] .)) = sameKind(M, TY1, TY) . eq isCommSameKind(M, OPD) = false [ owise ] . op isComm : AttrSet -> Bool . eq isComm(comm ATS) = true . eq isComm(ATS) = false [ owise ] . op isAssoc : AttrSet -> Bool . eq isAssoc(assoc ATS) = true . eq isAssoc(ATS) = false [ owise ] . op removeCtor : AttrSet -> AttrSet . eq removeCtor(ctor ATS) = ATS . eq removeCtor(ATS) = ATS [ owise ] . op constrTerm : Module OpDecl Nat -> Term . eq constrTerm(M, (op F : nil -> TY [ ATS ] .),N) = qid(alpha(string(F)) + "." + string(TY)) . eq constrTerm(M, (op F : TY1 TYL -> TY2 [ ATS ] .),N) = F[listVars(M, TY1 TYL, N)] . op constrToACTerm : Module OpDecl Nat -> Term . eq constrToACTerm(M, (op F : nil -> TY [ ATS ] .),N) = qid(alpha(string(F)) + "." + string(TY)) . eq constrToACTerm(M, (op F : TY1 TYL -> TY2 [ ATS ] .),N) = if isAssoc(ATS) xor isCommSameKind(M, (op F : TY1 TYL -> TY2 [ ATS ] .)) then qid(string(F) + "^AC")[toAClistVars(M, TY1 TYL, N)] else F[toAClistVars(M, TY1 TYL, N)] fi . op constrToACTermConds : Module OpDecl Term Nat -> EqCondition . eq constrToACTermConds(M, (op F : TY1 TYL -> TY2 [ ATS ] .),T, N) = toAClistVarConds(M, TY1 TYL,T,N) . op toAClistVarConds : Module TypeList Term Nat -> EqCondition . eq toAClistVarConds(M, TY nil, T, N) = '_=/=_[qid("V#" + string(s N,10) + ":" + string(getKind(M,TY))),T] = 'true.OBool . eq toAClistVarConds(M, TY TYL, T, N) = '_=/=_[qid("V#" + string(s N,10) + ":" + string(getKind(M,TY))),T] = 'true.OBool /\ toAClistVarConds(M, TYL, T, s N) [ owise ] . op listVars : Module TypeList Nat -> TermList . eq listVars(M, TY nil, N) = qid("V#" + string(s N,10) + ":" + string(getKind(M,TY))) . eq listVars(M, TY TYL, N) = qid("V#" + string(s N,10) + ":" + string(getKind(M,TY))) , listVars(M, TYL, s N) [ owise ] . op toAClistVars : Module TypeList Nat -> TermList . eq toAClistVars(M, TY nil, N) = 'toAC[qid("V#" + string(s N,10) + ":" + string(getKind(M,TY)))] . eq toAClistVars(M, TY TYL, N) = 'toAC[qid("V#" + string(s N,10) + ":" + string(getKind(M,TY)))] , toAClistVars(M, TYL, s N) [ owise ] . op typeListLength : TypeList -> Nat . eq typeListLength(nil) = 0 . eq typeListLength(TY TYL) = s typeListLength(TYL) . op fromTypeListToString : TypeList -> String . eq fromTypeListToString(nil) = "" . eq fromTypeListToString(TY TYL) = string(TY) + fromTypeListToString(TYL) . op setTopSort : TypeList -> Type . eq setTopSort(TY) = TY . eq setTopSort(TYL) = qid(fromTypeListToString(TYL)) [ owise ] . op newTopSorts : EKindOpDeclSetSet -> SortSet . eq newTopSorts((none).EKindOpDeclSetSet) = (none).SortSet . eq newTopSorts((TY [ TY ] :: OPDS) EKOPDS) = newTopSorts(EKOPDS) . eq newTopSorts((TY [ TYL ] :: OPDS) EKOPDS) = TY ; newTopSorts(EKOPDS) [ owise ] . op newSubsorts : EKindOpDeclSetSet -> SubsortDeclSet . eq newSubsorts((none).EKindOpDeclSetSet) = (none).SubsortDeclSet . eq newSubsorts((TY [ nil ] :: OPDS) EKOPDS) = newSubsorts(EKOPDS) . eq newSubsorts((TY1 [ TY2 TYL ] :: OPDS) EKOPDS) = if (TY1 == TY2) then newSubsorts((TY1 [ TYL ] :: OPDS) EKOPDS) else (subsort TY2 < TY1 .) newSubsorts((TY1 [ TYL ] :: OPDS) EKOPDS) fi . op processKinds : KindOpDeclSetSet -> EKindOpDeclSetSet . eq processKinds((none).KindOpDeclSetSet) = (none).EKindOpDeclSetSet . eq processKinds((K :: OPDS) KOPDS) = (setTopSort(extractTypes(string(K))) [ extractTypes(string(K)) ] :: OPDS) processKinds(KOPDS) . op extractTypes : String -> TypeList . eq extractTypes(STR) = if (substr(STR,0,2) == "`[") then extractTypes(substr(STR,2, length(STR))) else if (find(STR,"`,",0) =/= notFound) then (qid(substr(STR,0,find(STR,"`,",0))) extractTypes(substr(STR,find(STR,"`,",0) + 2, length(STR)))) else qid(substr(STR,0,find(STR,"`]",0))) fi fi . op toKind : Module TypeList -> TypeList . eq toKind(M,(nil).TypeList) = (nil).TypeList . eq toKind(M,TY) = getKind(M,TY) . eq toKind(M,TY TYL) = getKind(M,TY) toKind(M,TYL) [ owise ] . op getOpsByKind : Module KindOpDeclSetSet OpDeclSet -> KindOpDeclSetSet . eq getOpsByKind(M, KOPDS, (none).OpDeclSet) = KOPDS . eq getOpsByKind(M, KOPDS, (op F : TYL -> TY [ ATS special(NeHL:NeHookList) ] .) OPDS) = getOpsByKind(M, KOPDS, OPDS) . eq getOpsByKind(M, KOPDS, (op F : TYL -> TY [ ATS poly(NeNL:NeNatList) ] .) OPDS) = getOpsByKind(M, KOPDS, OPDS) . eq getOpsByKind(M, KOPDS, (op F : TYL -> TY [ ATS ] .) OPDS) = getOpsByKind(M, KOPDS, (op F : TYL -> TY [ ATS ] .) OPDS, getKind(M, TY)) [ owise ] . op getOpsByKind : Module KindOpDeclSetSet OpDeclSet Kind -> KindOpDeclSetSet . eq getOpsByKind(M, (K :: OPDS1) KOPDS, (op F : TYL -> TY [ ATS ] .) OPDS2, K) = getOpsByKind(M, (K :: (OPDS1 (op F : TYL -> TY [ ATS ] .))) KOPDS, OPDS2) . eq getOpsByKind(M, KOPDS, (op F : TYL -> TY [ ATS ] .) OPDS, K) = getOpsByKind(M, createKindSet(K,(op F : TYL -> TY [ ATS ] .)) KOPDS, OPDS) [ owise ] . op getEOpsByKind : Module KindOpDeclSetSet OpDeclSet -> KindOpDeclSetSet . eq getEOpsByKind(M, KOPDS, (none).OpDeclSet) = KOPDS . eq getEOpsByKind(M, KOPDS, (op F : TYL -> TY [ ATS special(NeHL:NeHookList) ] .) OPDS) = getEOpsByKind(M, KOPDS, OPDS) . eq getEOpsByKind(M, KOPDS, (op F : TYL -> TY [ ATS poly(NeNL:NeNatList) ] .) OPDS) = getEOpsByKind(M, KOPDS, OPDS) . eq getEOpsByKind(M, KOPDS, (op F : TYL -> TY [ ATS ] .) OPDS) = getEOpsByKind(M, KOPDS, (op F : TYL -> TY [ ATS ] .) OPDS, getKind(M, TY)) [ owise ] . op getEOpsByKind : Module KindOpDeclSetSet OpDeclSet Kind -> KindOpDeclSetSet . eq getEOpsByKind(M, (K :: OPDS1) KOPDS, (op F : TYL -> TY [ ATS ] .) OPDS2, K) = if isAssoc(ATS) xor isCommSameKind(M, (op F : TYL -> TY [ ATS ] .)) then getEOpsByKind(M, (K :: (OPDS1 (op F : TYL -> TY [ ATS ] .) (op qid(string(F) + "^AC") : toKind(M,TYL) -> TY [ assoc comm removeCtor(ATS) ] .))) KOPDS, OPDS2) else getEOpsByKind(M, (K :: (OPDS1 (op F : TYL -> TY [ ATS ] .))) KOPDS, OPDS2) fi . eq getEOpsByKind(M, KOPDS, (op F : TYL -> TY [ ATS ] .) OPDS, K) = if isAssoc(ATS) xor isCommSameKind(M, (op F : TYL -> TY [ ATS ] .)) then getEOpsByKind(M, createKindSet(K,(op F : TYL -> TY [ ATS ] .) (op qid(string(F) + "^AC") : toKind(M,TYL) -> TY [ assoc comm removeCtor(ATS) ] .)) KOPDS, OPDS) else getEOpsByKind(M, createKindSet(K,(op F : TYL -> TY [ ATS ] .)) KOPDS, OPDS) fi [ owise ] . op createKindSet : Kind OpDeclSet -> KindOpDeclSetSet . eq createKindSet(K, OPDS) = (K :: OPDS) . op constrWrapList : Module TypeList Nat -> Term . eq constrWrapList(M, nil, N) = 'nil.OWrapList . eq constrWrapList(M, TY TYL, N) = '__['`[`[_`]`][qid("V#" + string(N,10) + ":" + string(getKind(M,TY)))],constrWrapList(M, TYL, s N)] . op constrWrapSet : Module TypeList Nat -> Term . eq constrWrapSet(M, nil, N) = 'empty.OWrapSet . eq constrWrapSet(M, TY TYL, N) = '_`,_['`[`[_`]`][qid("V#" + string(N,10) + ":" + string(getKind(M,TY)))],constrWrapSet(M, TYL, s N)] . op mountEmbSmall4 : Module OpDecl OpDecl TypeList Nat -> Term . eq mountEmbSmall4(M, (op F1 : TYI1 TYI2 -> TY1 [ ATS1 ] .), (op F2 : TYL2 -> TY2 [ ATS2 ] .), (nil).TypeList,N) = qid("embSmall4-" + alpha(string(F1)))['_`,_['WS1:OWrapSet,'`[`[_`]`][constrTerm(M, (op F2 : TYL2 -> TY2 [ ATS2 ] .),0)]],'WS2:OWrapSet,'T:OTerm] . eq mountEmbSmall4(M, (op F1 : TYI1 TYI2 -> TY1 [ ATS1 ] .), (op F2 : TYL2 -> TY2 [ ATS2 ] .), TY3 TYL3, N) = '_or_['_>=v_[qid("(" + alpha(string(F1)) + ",_)")['_`,_['_`,_['WS1:OWrapSet,'`[`[_`]`][qid("V#" + string(N,10) + ":" + string(getKind(M,TY3)))]],'WS2:OWrapSet]],'T:OTerm],mountEmbSmall4(M, (op F1 : TYI1 TYI2 -> TY1 [ ATS1 ] .), (op F2 : TYL2 -> TY2 [ ATS2 ] .), TYL3, s N)] . op mountEmbSmall5 : Module OpDecl OpDecl TypeList Nat -> Term . eq mountEmbSmall5(M, (op F1 : TYI1 TYI2 -> TY1 [ ATS1 ] .), (op F2 : TYL2 -> TY2 [ ATS2 ] .), (nil).TypeList,N) = qid("embSmall5-" + alpha(string(F1)))['_`,_['WS1:OWrapSet,'`[`[_`]`][constrTerm(M, (op F2 : TYL2 -> TY2 [ ATS2 ] .),0)]],'WS2:OWrapSet,'T:OTerm] . eq mountEmbSmall5(M, (op F1 : TYI1 TYI2 -> TY1 [ ATS1 ] .), (op F2 : TYL2 -> TY2 [ ATS2 ] .), TY3 TYL3, N) = '_and_['_>v_['T:OTerm,qid("(" + alpha(string(F1)) + ",_)")['_`,_['_`,_['WS1:OWrapSet,'`[`[_`]`][qid("V#" + string(N,10) + ":" + string(getKind(M,TY3)))]],'WS2:OWrapSet]]],mountEmbSmall5(M, (op F1 : TYI1 TYI2 -> TY1 [ ATS1 ] .), (op F2 : TYL2 -> TY2 [ ATS2 ] .), TYL3, s N)] . op wrapSorts : Module SortSet -> OpDeclSet . eq wrapSorts(M, (none).SortSet) = none . eq wrapSorts(M, (TY ; SS)) = (op '`[`[_`]`] : getKind(M,TY) -> 'OWrap [ strat (0) ] .) wrapSorts(M, SS) . op aac-wrapSorts : Module SortSet -> OpDeclSet . eq aac-wrapSorts(M, (none).SortSet) = none . eq aac-wrapSorts(M, (TY ; SS)) = (op '`[`[_`]`] : getKind(M,TY) -> 'OWrap [ none ] .) (op 'toAC : getKind(M,TY) -> getKind(M,TY) [ none ] .) aac-wrapSorts(M,SS) . op wrapOps : EKindOpDeclSetSet -> OpDeclSet . eq wrapOps((none).EKindOpDeclSetSet) = none . eq wrapOps((TY [ TYL ] :: OPDS) EKOPDS) = wrapOps(OPDS) wrapOps(EKOPDS) . op wrapOps : OpDeclSet -> OpDeclSet . eq wrapOps((none).OpDeclSet) = (none).OpDeclSet . eq wrapOps((op F : TYL -> TY [ assoc comm ATS ] .) OPDS) = (op qid("(" + alpha(string(F)) + ",_)") : 'OWrapSet -> 'OTerm [ none ] .) (op qid("embSmall4-" + alpha(string(F))) : 'OWrapSet 'OWrapSet 'OTerm -> 'OBool [ none ] .) (op qid("embSmall5-" + alpha(string(F))) : 'OWrapSet 'OWrapSet 'OTerm -> 'OBool [ none ] .) (op qid("tf-" + alpha(string(F))) : 'OWrap -> 'OWrapSet [ none ] .) (op qid("noSmallHead-" + alpha(string(F))) : 'OWrapSet -> 'OWrapSet [ none ] .) (op qid("bigHead-" + alpha(string(F))) : 'OWrapSet 'OWrapSet -> 'OWrapSet [ none ] .) wrapOps(OPDS) . eq wrapOps((op F : TYL -> TY [ ATS ] .) OPDS) = (op qid("(" + alpha(string(F)) + ",_)") : 'OWrapList -> 'OTerm [ none ] .) wrapOps(OPDS) [ owise ] . op aac-wrapOps : EKindOpDeclSetSet -> OpDeclSet . eq aac-wrapOps((none).EKindOpDeclSetSet) = (none).OpDeclSet . eq aac-wrapOps((TY [ TYL ] :: OPDS) EKOPDS) = (op 'toACWrap : 'OWrap -> 'OWrap [ none ] .) aac-wrapOps(OPDS) aac-wrapOps(EKOPDS) . op aac-wrapOps : OpDeclSet -> OpDeclSet . eq aac-wrapOps((none).OpDeclSet) = (none).OpDeclSet . eq aac-wrapOps((op F : TYL -> TY [ assoc comm ATS ] .) OPDS) = (op qid("(" + alpha(string(F)) + ",_)") : 'OWrapSet -> 'OTerm [ none ] .) (op qid("embSmall4-" + alpha(string(F))) : 'OWrapSet 'OWrapSet 'OTerm -> 'OBool [ none ] .) (op qid("embSmall5-" + alpha(string(F))) : 'OWrapSet 'OWrapSet 'OTerm -> 'OBool [ none ] .) (op qid("tf-" + alpha(string(F))) : 'OWrap -> 'OWrapSet [ none ] .) (op qid("noSmallHead-" + alpha(string(F))) : 'OWrapSet -> 'OWrapSet [ none ] .) (op qid("bigHead-" + alpha(string(F))) : 'OWrapSet 'OWrapSet -> 'OWrapSet [ none ] .) (op qid("tf-" + alpha(string(F)) + "-set") : 'OWrap -> 'OWrapSet [ none ] .) aac-wrapOps(OPDS) . eq aac-wrapOps((op F : TYL -> TY [ ATS ] .) OPDS) = (op qid("(" + alpha(string(F)) + ",_)") : 'OWrapList -> 'OTerm [ none ] .) aac-wrapCommOps((op F : TYL -> TY [ ATS ] .),isComm(ATS)) aac-wrapOps(OPDS) [ owise ] . op aac-wrapCommOps : OpDeclSet Bool -> OpDeclSet . eq aac-wrapCommOps((op F : TYL -> TY [ ATS ] .), true) = (op qid("tf-" + alpha(string(F)) + "-set") : 'OWrap -> 'OWrapSet [ none ] .) . eq aac-wrapCommOps((op F : TYL -> TY [ ATS ] .), false) = (op qid("tf-" + alpha(string(F)) + "-list") : 'OWrap -> 'OWrapList [ none ] .) . op wrapEqs : -> EquationSet . eq wrapEqs = (eq 'wrapToTerm['W:OWrap] = '`(variable`,_`)['W:OWrap] [ owise ] .) (eq '_>v_['`(variable`,_`)['W:OWrap],'T:OTerm] = 'false.OBool [ none ] .) . op aac-wrapSortEqs : Module SortSet -> EquationSet . eq aac-wrapSortEqs(M, (none).SortSet) = none . eq aac-wrapSortEqs(M, (TY ; SS)) = (eq 'toACWrap['`[`[_`]`][qid("V#1:" + string(getKind(M,TY)))]] = '`[`[_`]`]['toAC[qid("V#1:" + string(getKind(M,TY)))]] [ none ] .) (eq 'toAC[qid("V#1:" + string(getKind(M,TY)))] = qid("V#1:" + string(getKind(M,TY))) [ owise ] .) aac-wrapSortEqs(M, SS) . op aac-wrapEqs : EKindOpDeclSetSet -> EquationSet . eq aac-wrapEqs(none) = (eq 'wrapToTerm['W:OWrap] = '`(variable`,_`)['W:OWrap] [ owise ] .) (eq '_>v_['`(variable`,_`)['W:OWrap],'T:OTerm] = 'false.OBool [ none ] .) . eq aac-wrapEqs((TY [ TYL ] :: OPDS) EKOPDS) = aac-wrapEqs(EKOPDS) . op fromOpDeclToNatOpDecl : OpDecl -> NatOpDecl . ceq fromOpDeclToNatOpDecl((op F : TYL -> TY [ ATS metadata(STR) ] .)) = (rat(STR,10),(op F : TYL -> TY [ ATS metadata(STR) ] .)) if rat(STR,10) :: Nat . eq fromOpDeclToNatOpDecl((op F : TYL -> TY [ ATS ] .)) = (0,(op F : TYL -> TY [ ATS ] .)) [ owise ] . op fromOpDeclSetToNatOpDeclList : OpDeclSet -> NatOpDeclList . eq fromOpDeclSetToNatOpDeclList((none).OpDeclSet) = (nil).NatOpDeclList . eq fromOpDeclSetToNatOpDeclList((op F : TYL -> TY [ ATS special(NeHL:NeHookList) ] . OPDS)) = fromOpDeclSetToNatOpDeclList(OPDS) . eq fromOpDeclSetToNatOpDeclList((op F : TYL -> TY [ ATS poly(NeNL:NeNatList) ] . OPDS)) = fromOpDeclSetToNatOpDeclList(OPDS) . eq fromOpDeclSetToNatOpDeclList((OPD OPDS)) = fromOpDeclToNatOpDecl(OPD) fromOpDeclSetToNatOpDeclList(OPDS) [ owise ] . op addACOpDecl : Module OpDeclSet -> OpDeclSet . eq addACOpDecl(M, none) = none . eq addACOpDecl(M, (op F : TYL -> TY [ ATS ] .)) = if isAssoc(ATS) xor isCommSameKind(M, (op F : TYL -> TY [ ATS ] .)) then ((op F : TYL -> TY [ ATS ] .) (op qid(string(F) + "^AC") : toKind(M,TYL) -> getKind(M,TY) [ assoc comm removeCtor(ATS) ] .)) else (op F : TYL -> TY [ ATS ] .) fi . eq addACOpDecl(M, (OPD OPDS)) = addACOpDecl(M, OPD) addACOpDecl(M, OPDS) . op constrGreaterEqs : OpDecl -> EquationSet . eq constrGreaterEqs((op F : TYL -> TY [ assoc comm ATS ] .)) = (eq '_>v_[qid("(" + alpha(string(F)) + ",_)")['WS:OWrapSet],'T:OTerm] = 'acrpo5-1-set['WS:OWrapSet,'T:OTerm] [ owise ] .) . eq constrGreaterEqs((op F : TYL -> TY [ ATS ] .)) = (eq '_>v_[qid("(" + alpha(string(F)) + ",_)")['WL:OWrapList],'T:OTerm] = 'acrpo5-1-list['WL:OWrapList,'T:OTerm] [ owise ] .) [ owise ] . op aac-constrGreaterEqs : Module OpDecl -> EquationSet . eq aac-constrGreaterEqs(M, (op F : TYL -> TY [ assoc comm ATS ] .)) = (eq '_>v_[qid("(" + alpha(string(F)) + ",_)")['WS:OWrapSet],'T:OTerm] = 'acrpo5-1-set['WS:OWrapSet,'T:OTerm] [ owise ] .) (eq '_>E_['`[`[_`]`][constrTerm(M, (op F : TYL -> TY [ ATS ] .),0)],'W2:OWrap] = '_>v_['`[`[_`]`]['toAC[constrTerm(M, (op F : TYL -> TY [ ATS ] .),0)]],'toACWrap['W2:OWrap]] [ owise ] .) . eq aac-constrGreaterEqs(M, (op F : TYL -> TY [ ATS ] .)) = (eq '_>v_[qid("(" + alpha(string(F)) + ",_)")['WL:OWrapList],'T:OTerm] = 'acrpo5-1-list['WL:OWrapList,'T:OTerm] [ owise ] .) (eq '_>E_['`[`[_`]`][constrTerm(M,(op F : TYL -> TY [ ATS ] .),0)],'W2:OWrap] = '_>v_['`[`[_`]`]['toAC[constrTerm(M, (op F : TYL -> TY [ ATS ] .),0)]],'toACWrap['W2:OWrap]] [ owise ] .) [ owise ] . op constrSmallerEqs : OpDecl NatOpDeclList -> EquationSet . eq constrSmallerEqs(OPD, (nil).NatOpDeclList) = (none).EquationSet . eq constrSmallerEqs((op F1 : TYL1 -> TY1 [ ATS1 ] .), (N,(op F2 : TYL2 -> TY2 [ ATS2 ] .)) NOPDL) = if isComm(ATS1) and-then isAssoc(ATS1) then if isComm(ATS2) and-then isAssoc(ATS2) then (eq '_>v_[qid("(" + alpha(string(F1)) + ",_)")['WS1:OWrapSet],qid("(" + alpha(string(F2)) + ",_)")['WS2:OWrapSet]] = '_or_['acrpo5-1-set['WS1:OWrapSet,qid("(" + alpha(string(F2)) + ",_)")['WS2:OWrapSet]],'acrpo5-2-set[qid("(" + alpha(string(F1)) + ",_)")['WS1:OWrapSet],'WS2:OWrapSet]] [ none ] .) else (eq '_>v_[qid("(" + alpha(string(F1)) + ",_)")['WS1:OWrapSet],qid("(" + alpha(string(F2)) + ",_)")['WL2:OWrapList]] = '_or_['acrpo5-1-set['WS1:OWrapSet,qid("(" + alpha(string(F2)) + ",_)")['WL2:OWrapList]],'acrpo5-2-list[qid("(" + alpha(string(F1)) + ",_)")['WS1:OWrapSet],'WL2:OWrapList]] [ none ] .) fi else if isComm(ATS2) and-then isAssoc(ATS2) then (eq '_>v_[qid("(" + alpha(string(F1)) + ",_)")['WL1:OWrapList],qid("(" + alpha(string(F2)) + ",_)")['WS2:OWrapSet]] = '_or_['acrpo5-1-list['WL1:OWrapList,qid("(" + alpha(string(F2)) + ",_)")['WS2:OWrapSet]],'acrpo5-2-set[qid("(" + alpha(string(F1)) + ",_)")['WL1:OWrapList],'WS2:OWrapSet]] [ none ] .) else (eq '_>v_[qid("(" + alpha(string(F1)) + ",_)")['WL1:OWrapList],qid("(" + alpha(string(F2)) + ",_)")['WL2:OWrapList]] = '_or_['acrpo5-1-list['WL1:OWrapList,qid("(" + alpha(string(F2)) + ",_)")['WL2:OWrapList]],'acrpo5-2-list[qid("(" + alpha(string(F1)) + ",_)")['WL1:OWrapList],'WL2:OWrapList]] [ none ] .) fi fi constrSmallerEqs((op F1 : TYL1 -> TY1 [ ATS1 ] .), NOPDL) . op aac-constrSmallerEqs : Module OpDecl NatOpDeclList -> EquationSet . eq aac-constrSmallerEqs(M, OPD, (nil).NatOpDeclList) = (none).EquationSet . eq aac-constrSmallerEqs(M, (op F1 : TYL1 -> TY1 [ ATS1 ] .), (N,(op F2 : TYL2 -> TY2 [ ATS2 ] .)) NOPDL) = if isComm(ATS1) and-then isAssoc(ATS1) then if isComm(ATS2) and-then isAssoc(ATS2) then (eq '_>v_[qid("(" + alpha(string(F1)) + ",_)")['WS1:OWrapSet],qid("(" + alpha(string(F2)) + ",_)")['WS2:OWrapSet]] = '_or_['acrpo5-1-set['WS1:OWrapSet,qid("(" + alpha(string(F2)) + ",_)")['WS2:OWrapSet]],'acrpo5-2-set[qid("(" + alpha(string(F1)) + ",_)")['WS1:OWrapSet],'WS2:OWrapSet]] [ none ] .) else (eq '_>v_[qid("(" + alpha(string(F1)) + ",_)")['WS1:OWrapSet],qid("(" + alpha(string(F2)) + ",_)")['WL2:OWrapList]] = '_or_['acrpo5-1-set['WS1:OWrapSet,qid("(" + alpha(string(F2)) + ",_)")['WL2:OWrapList]],'acrpo5-2-list[qid("(" + alpha(string(F1)) + ",_)")['WS1:OWrapSet],'WL2:OWrapList]] [ none ] .) fi else if isComm(ATS2) and-then isAssoc(ATS2) then (eq '_>v_[qid("(" + alpha(string(F1)) + ",_)")['WL1:OWrapList],qid("(" + alpha(string(F2)) + ",_)")['WS2:OWrapSet]] = '_or_['acrpo5-1-list['WL1:OWrapList,qid("(" + alpha(string(F2)) + ",_)")['WS2:OWrapSet]],'acrpo5-2-set[qid("(" + alpha(string(F1)) + ",_)")['WL1:OWrapList],'WS2:OWrapSet]] [ none ] .) else (eq '_>v_[qid("(" + alpha(string(F1)) + ",_)")['WL1:OWrapList],qid("(" + alpha(string(F2)) + ",_)")['WL2:OWrapList]] = '_or_['acrpo5-1-list['WL1:OWrapList,qid("(" + alpha(string(F2)) + ",_)")['WL2:OWrapList]],'acrpo5-2-list[qid("(" + alpha(string(F1)) + ",_)")['WL1:OWrapList],'WL2:OWrapList]] [ none ] .) fi fi (eq '_>E_['`[`[_`]`][constrTerm(M, (op F1 : TYL1 -> TY1 [ ATS1 ] .),0)],'`[`[_`]`][constrTerm(M, (op F2 : TYL2 -> TY2 [ ATS2 ] .),typeListLength(TYL1))]] = '_>v_['`[`[_`]`]['toAC[constrTerm(M, (op F1 : TYL1 -> TY1 [ ATS1 ] .),0)]],'`[`[_`]`]['toAC[constrTerm(M, (op F2 : TYL2 -> TY2 [ ATS2 ] .),typeListLength(TYL1))]]] [ none ] .) aac-constrSmallerEqs(M, (op F1 : TYL1 -> TY1 [ ATS1 ] .), NOPDL) . op constrEqualEqs : OpDecl -> EquationSet . eq constrEqualEqs((op F : TYI1 TYI2 -> TY [ assoc comm ATS ] .)) = (eq '_>v_[qid("(" + alpha(string(F)) + ",_)")['WS1:OWrapSet],qid("(" + alpha(string(F)) + ",_)")['WS2:OWrapSet]] = '_or_['acrpo5-1-set['WS1:OWrapSet,qid("(" + alpha(string(F)) + ",_)")['WS2:OWrapSet]],qid("embSmall4-" + alpha(string(F)))['empty.OWrapSet,'WS1:OWrapSet, qid("(" + alpha(string(F)) + ",_)")['WS2:OWrapSet]]] [ none ] .) . eq constrEqualEqs((op F : TYL -> TY [ ATS ] .)) = (eq '_>v_[qid("(" + alpha(string(F)) + ",_)")['WL1:OWrapList],qid("(" + alpha(string(F)) + ",_)")['WL2:OWrapList]] = '_or_['acrpo5-1-list['WL1:OWrapList, qid("(" + alpha(string(F)) + ",_)")['WL2:OWrapList]], '_and_['_>v`{lex`}_['WL1:OWrapList,'WL2:OWrapList], 'acrpo5-2-list[qid("(" + alpha(string(F)) + ",_)")['WL1:OWrapList],'WL2:OWrapList]]] [ none ] .) [ owise ] . op aac-constrEqualEqs : Module OpDecl -> EquationSet . eq aac-constrEqualEqs(M, (op F : TYL -> TY [ comm ATS ] .)) = if isAssoc(ATS) then (eq '_>v_[qid("(" + alpha(string(F)) + ",_)")['WS1:OWrapSet],qid("(" + alpha(string(F)) + ",_)")['WS2:OWrapSet]] = '_or_['acrpo5-1-set['WS1:OWrapSet,qid("(" + alpha(string(F)) + ",_)")['WS2:OWrapSet]],qid("embSmall4-" + alpha(string(F)))['empty.OWrapSet,'WS1:OWrapSet, qid("(" + alpha(string(F)) + ",_)")['WS2:OWrapSet]]] [ none ] .) else (eq '_>v_[qid("(" + alpha(string(F)) + ",_)")['WL1:OWrapList],qid("(" + alpha(string(F)) + ",_)")['WL2:OWrapList]] = '_or_['acrpo5-1-list['WL1:OWrapList, qid("(" + alpha(string(F)) + ",_)")['WL2:OWrapList]], '_and_['_>v`{lex`}_['WL1:OWrapList,'WL2:OWrapList], 'acrpo5-2-list[qid("(" + alpha(string(F)) + ",_)")['WL1:OWrapList],'WL2:OWrapList]]] [ none ] .) fi (eq '_>E_['`[`[_`]`][constrTerm(M, (op F : TYL -> TY [ comm ATS ] .),0)],'`[`[_`]`][constrTerm(M, (op F : TYL -> TY [ comm ATS ] .),typeListLength(TYL))]] = 'if_then_else_fi['_==_['_>v_['`[`[_`]`]['toAC[constrTerm(M, (op F : TYL -> TY [ comm ATS ] .),0)]],'`[`[_`]`]['toAC[constrTerm(M, (op F : TYL -> TY [ comm ATS ] .),typeListLength(TYL))]]],'true.OBool],'true.OBool,'if_then_else_fi['_==_['`[`[_`]`]['toAC[constrTerm(M, (op F : TYL -> TY [ comm ATS ] .),0)]],'`[`[_`]`]['toAC[constrTerm(M, (op F : TYL -> TY [ comm ATS ] .),typeListLength(TYL))]]],'_>>E_[qid("tf-" + alpha(string(F)) + "-set")['`[`[_`]`][constrTerm(M, (op F : TYL -> TY [ comm ATS ] .),0)]],qid("tf-" + alpha(string(F)) + "-set")['`[`[_`]`][constrTerm(M, (op F : TYL -> TY [ comm ATS ] .),typeListLength(TYL))]]],'false.OBool]] [ none ] .) . eq aac-constrEqualEqs(M, (op F : TYL -> TY [ ATS ] .)) = (eq '_>v_[qid("(" + alpha(string(F)) + ",_)")['WL1:OWrapList],qid("(" + alpha(string(F)) + ",_)")['WL2:OWrapList]] = '_or_['acrpo5-1-list['WL1:OWrapList, qid("(" + alpha(string(F)) + ",_)")['WL2:OWrapList]], '_and_['_>v`{lex`}_['WL1:OWrapList,'WL2:OWrapList], 'acrpo5-2-list[qid("(" + alpha(string(F)) + ",_)")['WL1:OWrapList],'WL2:OWrapList]]] [ none ] .) (eq '_>E_['`[`[_`]`][constrTerm(M, (op F : TYL -> TY [ ATS ] .),0)],'`[`[_`]`][constrTerm(M, (op F : TYL -> TY [ ATS ] .),typeListLength(TYL))]] = 'if_then_else_fi['_==_['_>v_['`[`[_`]`]['toAC[constrTerm(M, (op F : TYL -> TY [ ATS ] .),0)]],'`[`[_`]`]['toAC[constrTerm(M, (op F : TYL -> TY [ ATS ] .),typeListLength(TYL))]]],'true.OBool],'true.OBool,'if_then_else_fi['_==_['`[`[_`]`]['toAC[constrTerm(M, (op F : TYL -> TY [ ATS ] .),0)]],'`[`[_`]`]['toAC[constrTerm(M, (op F : TYL -> TY [ ATS ] .),typeListLength(TYL))]]],'_>E`{lex`}_[qid("tf-" + alpha(string(F)) + "-list")['`[`[_`]`][constrTerm(M, (op F : TYL -> TY [ ATS ] .),0)]],qid("tf-" + alpha(string(F)) + "-list")['`[`[_`]`][constrTerm(M, (op F : TYL -> TY [ ATS ] .),typeListLength(TYL))]]],'false.OBool]] [ none ] .) [ owise ] . op aac-constrToACEqs : Module OpDecl -> EquationSet . eq aac-constrToACEqs(M, (op F : TYL -> TY [ id(T) ATS ] .)) = (ceq 'toAC[constrTerm(M, (op F : TYL -> TY [ id(T) ATS ] .),0)] = constrToACTerm(M, (op F : TYL -> TY [ id(T) ATS ] .),0) if constrToACTermConds(M, (op F : TYL -> TY [ id(T) ATS ] .),T,0) [ none ] .) . eq aac-constrToACEqs(M, (op F : TYL -> TY [ ATS ] .)) = (eq 'toAC[constrTerm(M,(op F : TYL -> TY [ ATS ] .),0)] = constrToACTerm(M, (op F : TYL -> TY [ ATS ] .),0) [ none ] .) [ owise ] . op constrWrapToTermEqs : Module NatOpDeclList -> EquationSet . eq constrWrapToTermEqs(M, (nil).NatOpDeclList) = none . eq constrWrapToTermEqs(M, (N,(op F : TYI1 TYI2 -> TY [ assoc comm ATS ] .)) NOPDL) = constrWrapToTermIdsEqs(M, (N,(op F : TYI1 TYI2 -> TY [ assoc comm ATS ] .))) constrWrapToTermEqs(M, NOPDL) . eq constrWrapToTermEqs(M, (N,(op F : TYL -> TY [ ATS ] .)) NOPDL) = (eq 'wrapToTerm['`[`[_`]`][constrTerm(M, (op F : TYL -> TY [ ATS ] .),0)]] = qid("(" + alpha(string(F)) + ",_)")[constrWrapList(M, TYL,1)] [ none ] .) constrWrapToTermEqs(M, NOPDL) [ owise ] . op constrWrapToTermIdsEqs : Module NatOpDecl -> Equation . eq constrWrapToTermIdsEqs(M, (N,(op F : TYI1 TYI2 -> TY [ assoc comm id(T) ATS ] .))) = (ceq 'wrapToTerm['`[`[_`]`][constrTerm(M, (op F : TYI1 TYI2 -> TY [ assoc comm id(T) ATS ] .),0)]] = qid("(" + alpha(string(F)) + ",_)")[qid("tf-" + alpha(string(F)))['`[`[_`]`][constrTerm(M, (op F : TYI1 TYI2 -> TY [ assoc comm id(T) ATS ] .),0)]]] if constrToACTermConds(M, (op F : TYI1 TYI2 -> TY [ assoc comm id(T) ATS ] .),T,0) [ none ] .) . eq constrWrapToTermIdsEqs(M, (N,(op F : TYI1 TYI2 -> TY [ assoc comm ATS ] .))) = (eq 'wrapToTerm['`[`[_`]`][constrTerm(M, (op F : TYI1 TYI2 -> TY [ assoc comm ATS ] .),0)]] = qid("(" + alpha(string(F)) + ",_)")[qid("tf-" + alpha(string(F)))['`[`[_`]`][constrTerm(M, (op F : TYI1 TYI2 -> TY [ assoc comm ATS ] .),0)]]] [ none ] .) [ owise ] . op constrWrapEqs : Module NatOpDeclList NatOpDeclList -> EquationSet . eq constrWrapEqs(M, NOPDL, (nil).NatOpDeclList) = (eq 'sharp['WS:OWrapSet,'N:ONat] = '`(_`,_`)['WS:OWrapSet,'N:ONat] [ owise ] .) constrWrapToTermEqs(M, NOPDL) . eq constrWrapEqs(M, NOPDL1, (N,(op F : TYL -> TY [ ATS ] .)) NOPDL2) = constrGreaterEqs((op F : TYL -> TY [ ATS ] .)) constrSmallerEqs((op F : TYL -> TY [ ATS ] .),NOPDL1) constrEqualEqs((op F : TYL -> TY [ ATS ] .)) if isComm(ATS) and-then isAssoc(ATS) then constrACEqs(M, (op F : TYL -> TY [ ATS ] .),NOPDL1) constrBHEqs(M, (op F : TYL -> TY [ ATS ] .),NOPDL2) else none fi constrSharpEqs(M, (op F : TYL -> TY [ ATS ] .)) constrWrapEqs(M, NOPDL1 (N,(op F : TYL -> TY [ ATS ] .)), NOPDL2) . op aac-constrWrapEqs : Module NatOpDeclList NatOpDeclList -> EquationSet . eq aac-constrWrapEqs(M, NOPDL, (nil).NatOpDeclList) = (eq 'sharp['WS:OWrapSet,'N:ONat] = '`(_`,_`)['WS:OWrapSet,'N:ONat] [ owise ] .) constrWrapToTermEqs(M, NOPDL) . eq aac-constrWrapEqs(M, NOPDL1, (N,(op F : TYL -> TY [ ATS ] .)) NOPDL2) = aac-constrGreaterEqs(M, (op F : TYL -> TY [ ATS ] .)) aac-constrSmallerEqs(M, (op F : TYL -> TY [ ATS ] .),NOPDL1) aac-constrEqualEqs(M, (op F : TYL -> TY [ ATS ] .)) aac-constrToACEqs(M, (op F : TYL -> TY [ ATS ] .)) if isComm(ATS) and-then isAssoc(ATS) then constrACEqs(M, (op F : TYL -> TY [ ATS ] .),NOPDL1) constrBHEqs(M, (op F : TYL -> TY [ ATS ] .),NOPDL2) else none fi constrSharpEqs(M, (op F : TYL -> TY [ ATS ] .)) aac-constrtfEqs(M, (op F : TYL -> TY [ ATS ] .)) aac-constrWrapEqs(M, NOPDL1 (N,(op F : TYL -> TY [ ATS ] .)), NOPDL2) . op constrACEqs : Module OpDecl NatOpDeclList -> EquationSet . eq constrACEqs(M, (op F : TYI1 TYI2 -> TY [ ATS ] .), (nil).NatOpDeclList) = constrtfACEqs(M, (op F : TYI1 TYI2 -> TY [ ATS ] .)) (eq qid("embSmall4-" + alpha(string(F)))['WS1:OWrapSet,'WS2:OWrapSet,qid("(" + alpha(string(F)) + ",_)")['WS3:OWrapSet]] = qid("embSmall5-" + alpha(string(F)))['empty.OWrapSet,'WS3:OWrapSet,qid("(" + alpha(string(F)) + ",_)")['_`,_['WS1:OWrapSet,'WS2:OWrapSet]]] [ owise ] .) (eq qid("embSmall5-" + alpha(string(F)))['WS1:OWrapSet,'WS2:OWrapSet,qid("(" + alpha(string(F)) + ",_)")['WS3:OWrapSet]] = '_and_['_>>=v_[qid("noSmallHead-" + alpha(string(F)))['WS3:OWrapSet],qid("noSmallHead-" + alpha(string(F)))['_`,_['WS1:OWrapSet,'WS2:OWrapSet]]],'_or_['_>>v_[qid("bigHead-" + alpha(string(F)))['empty.OWrapSet,'WS3:OWrapSet],qid("bigHead-" + alpha(string(F)))['empty.OWrapSet,'_`,_['WS1:OWrapSet,'WS2:OWrapSet]]],'_or_['_>_['sharp['WS3:OWrapSet,'0.ONat],'sharp['_`,_['WS1:OWrapSet,'WS2:OWrapSet],'0.ONat]],'_and_['_>=_['sharp['WS3:OWrapSet,'0.ONat],'sharp['_`,_['WS1:OWrapSet,'WS2:OWrapSet],'0.ONat]],'_>>v_['WS3:OWrapSet,'_`,_['WS1:OWrapSet,'WS2:OWrapSet]]]]]] [ owise ] .) (eq qid("noSmallHead-" + alpha(string(F)))['WS:OWrapSet] = 'WS:OWrapSet [ owise ] .) . eq constrACEqs(M, (op F1 : TYI1 TYI2 -> TY1 [ ATS1 ] .), (N,(op F2 : TYL2 -> TY2 [ ATS2 ] .)) NOPDL) = (eq qid("embSmall4-" + alpha(string(F1)))['WS1:OWrapSet,'_`,_['`[`[_`]`][constrTerm(M, (op F2 : TYL2 -> TY2 [ ATS2 ] .),0)],'WS2:OWrapSet],'T:OTerm] = mountEmbSmall4(M, (op F1 : TYI1 TYI2 -> TY1 [ ATS1 ] .), (op F2 : TYL2 -> TY2 [ ATS2 ] .),TYL2,1) [ none ] .) (eq qid("embSmall5-" + alpha(string(F1)))['WS1:OWrapSet,'_`,_['`[`[_`]`][constrTerm(M, (op F2 : TYL2 -> TY2 [ ATS2 ] .),0)],'WS2:OWrapSet],'T:OTerm] = mountEmbSmall5(M, (op F1 : TYI1 TYI2 -> TY1 [ ATS1 ] .), (op F2 : TYL2 -> TY2 [ ATS2 ] .),TYL2,1) [ none ] .) (eq qid("noSmallHead-" + alpha(string(F1)))['_`,_['`[`[_`]`][constrTerm(M, (op F2 : TYL2 -> TY2 [ ATS2 ] .),0)],'WS:OWrapSet]] = qid("noSmallHead-" + alpha(string(F1)))['WS:OWrapSet] [ none ] .) constrACEqs(M, (op F1 : TYI1 TYI2 -> TY1 [ ATS1 ] .), NOPDL) . op constrtfACEqs : Module OpDecl -> EquationSet . eq constrtfACEqs(M, (op F : TYI1 TYI2 -> TY [ id(T) ATS ] .)) = (ceq qid("tf-" + alpha(string(F)))['`[`[_`]`][constrTerm(M, (op F : TYI1 TYI2 -> TY [ id(T) ATS ] .),0)]] = '_`,_[qid("tf-" + alpha(string(F)))['`[`[_`]`][qid("V#" + string(1,10) + ":" + string(getKind(M,TYI1)))]],qid("tf-" + alpha(string(F)))['`[`[_`]`][qid("V#" + string(2,10) + ":" + string(getKind(M,TYI2)))]]] if constrToACTermConds(M, (op F : TYI1 TYI2 -> TY [ id(T) ATS ] .),T,0) [ none ] .) (eq qid("tf-" + alpha(string(F)))['W:OWrap] = 'W:OWrap [ owise ] .) . eq constrtfACEqs(M, (op F : TYI1 TYI2 -> TY [ ATS ] .)) = (eq qid("tf-" + alpha(string(F)))['`[`[_`]`][constrTerm(M, (op F : TYI1 TYI2 -> TY [ ATS ] .),0)]] = '_`,_[qid("tf-" + alpha(string(F)))['`[`[_`]`][qid("V#" + string(1,10) + ":" + string(getKind(M,TYI1)))]],qid("tf-" + alpha(string(F)))['`[`[_`]`][qid("V#" + string(2,10) + ":" + string(getKind(M,TYI2)))]]] [ none ] .) (eq qid("tf-" + alpha(string(F)))['W:OWrap] = 'W:OWrap [ owise ] .) [ owise ] . op constrBHEqs : Module OpDecl NatOpDeclList -> EquationSet . eq constrBHEqs(M, (op F : TYI1 TYI2 -> TY [ ATS ] .), (nil).NatOpDeclList) = (eq qid("bigHead-" + alpha(string(F)))['WS1:OWrapSet,'WS2:OWrapSet] = 'WS1:OWrapSet [ owise ] .) . eq constrBHEqs(M, (op F1 : TYI1 TYI2 -> TY1 [ ATS1 ] .), (N,(op F2 : TYL2 -> TY2 [ ATS2 ] .)) NOPDL) = (eq qid("bigHead-" + alpha(string(F1)))['WS1:OWrapSet,'_`,_['`[`[_`]`][constrTerm(M, (op F2 : TYL2 -> TY2 [ ATS2 ] .),0)],'WS2:OWrapSet]] = qid("bigHead-" + alpha(string(F1)))['_`,_['WS1:OWrapSet,'`[`[_`]`][constrTerm(M, (op F2 : TYL2 -> TY2 [ ATS2 ] .),0)]],'WS2:OWrapSet] [ none ] .) constrBHEqs(M,(op F1 : TYI1 TYI2 -> TY1 [ ATS1 ] .), NOPDL) . op constrSharpEqs : Module OpDecl -> EquationSet . eq constrSharpEqs(M, (op F : TYL -> TY [ ATS ] .)) = (eq 'sharp['_`,_['`[`[_`]`][constrTerm(M, (op F : TYL -> TY [ ATS ] .),0)],'WS:OWrapSet],'N:ONat] = 'sharp['WS:OWrapSet,'s_['N:ONat]] [ none ] .) . op aac-constrtfEqs : Module OpDecl -> EquationSet . eq aac-constrtfEqs(M, (op F : TYI1 TYI2 -> TY [ assoc comm ATS ] .)) = (eq qid("tf-" + alpha(string(F)) + "-set")['`[`[_`]`][constrTerm(M, (op F : TYI1 TYI2 -> TY [ assoc comm ATS ] .),0)]] = '_`,_[qid("tf-" + alpha(string(F)) + "-set")['`[`[_`]`][qid("V#" + string(1,10) + ":" + string(getKind(M,TYI1)))]],qid("tf-" + alpha(string(F)) + "-set")['`[`[_`]`][qid("V#" + string(2,10) + ":" + string(getKind(M, TYI2)))]]] [ none ] .) (eq qid("tf-" + alpha(string(F)) + "-set")['W:OWrap] = 'W:OWrap [ owise ] .) . eq aac-constrtfEqs(M,(op F : TYL -> TY [ ATS ] .)) = aac-constrtfCommEqs(M, (op F : TYL -> TY [ ATS ] .), isComm(ATS)) [ owise ] . op aac-constrtfCommEqs : Module OpDecl Bool -> EquationSet . eq aac-constrtfCommEqs(M, (op F : TYL -> TY [ ATS ] .), true) = (eq qid("tf-" + alpha(string(F)) + "-set")['`[`[_`]`][constrTerm(M, (op F : TYL -> TY [ ATS ] .),0)]] = constrWrapSet(M, TYL,1) [ none ] .) (eq qid("tf-" + alpha(string(F)) + "-set")['W:OWrap] = 'W:OWrap [ owise ] .) . eq aac-constrtfCommEqs(M, (op F : TYL -> TY [ ATS ] .), false) = aac-constrtfAssocEqs(M, (op F : TYL -> TY [ ATS ] .), isAssoc(ATS)) [ owise ] . op aac-constrtfAssocEqs : Module OpDecl Bool -> EquationSet . eq aac-constrtfAssocEqs(M, (op F : TYI1 TYI2 -> TY [ ATS ] .), true) = (eq qid("tf-" + alpha(string(F)) + "-list")['`[`[_`]`][constrTerm(M, (op F : TYI1 TYI2 -> TY [ ATS ] .),0)]] = '__[qid("tf-" + alpha(string(F)) + "-list")['`[`[_`]`][qid("V#" + string(1,10) + ":" + string(getKind(M,TYI1)))]],qid("tf-" + alpha(string(F)) + "-list")['`[`[_`]`][qid("V#" + string(2,10) + ":" + string(getKind(M,TYI2)))]]] [ none ] .) (eq qid("tf-" + alpha(string(F)) + "-list")['W:OWrap] = 'W:OWrap [ owise ] .) . eq aac-constrtfAssocEqs(M, (op F : TYL -> TY [ ATS ] .), false) = (eq qid("tf-" + alpha(string(F)) + "-list")['`[`[_`]`][constrTerm(M, (op F : TYL -> TY [ ATS ] .),0)]] = constrWrapList(M, TYL,1) [ none ] .) [ owise ] . op aac-compWithOrd : Module -> FModule . eq aac-compWithOrd(fmod H is IL sorts 'Bool ; SS . SSDS OPDS (op 'false : nil -> 'Bool [ ctor special(id-hook('SystemFalse, nil)) ] .) (op 'true : nil -> 'Bool [ ctor special(id-hook('SystemTrue, nil)) ] .) MAS EQS endfm) = aac-compWithOrd'(fmod H is IL sorts 'Bool ; SS . SSDS OPDS (op 'false : nil -> 'Bool [ ctor metadata("0") ].) (op 'true : nil -> 'Bool [ ctor metadata("0") ] .) MAS EQS endfm) . eq aac-compWithOrd(mod H is IL sorts 'Bool ; SS . SSDS OPDS (op 'false : nil -> 'Bool [ ctor special(id-hook('SystemFalse, nil)) ] .) (op 'true : nil -> 'Bool [ ctor special(id-hook('SystemTrue, nil)) ] .) MAS EQS RLS endm) = aac-compWithOrd'(fmod H is IL sorts 'Bool ; SS . SSDS OPDS (op 'false : nil -> 'Bool [ ctor metadata("0") ].) (op 'true : nil -> 'Bool [ ctor metadata("0") ] .) MAS EQS endfm) . eq aac-compWithOrd(M) = aac-compWithOrd'(M) [ owise ] . op aac-compWithOrd' : Module -> Module . eq aac-compWithOrd'(fmod H is IL sorts SS . SSDS OPDS MAS EQS endfm) = fmod H is IL (protecting 'NAT * ( sort 'Bool to 'OBool, sort 'Zero to 'OZero, sort 'NzNat to 'ONzNat, sort 'Nat to 'ONat) .) sorts (SS ; 'OTerm ; 'OWrap ; 'OWrapList ; 'OWrapSet ; 'OWrapPolynomial ; newTopSorts(processKinds(getOpsByKind(fmod H is IL sorts SS . SSDS OPDS MAS EQS endfm, (none).KindOpDeclSetSet, OPDS)))) . (subsort 'OWrap < 'OWrapList .) (subsort 'OWrap < 'OWrapSet .) newSubsorts(processKinds(getOpsByKind(fmod H is IL sorts SS . SSDS OPDS MAS EQS endfm, (none).KindOpDeclSetSet, OPDS))) SSDS (op 'nil : nil -> 'OWrapList [ ctor ] .) (op '__ : 'OWrapList 'OWrapList -> 'OWrapList [ ctor assoc id('nil.OWrapList) ] .) (op 'empty : nil -> 'OWrapSet [ ctor ] .) (op '_`,_ : 'OWrapSet 'OWrapSet -> 'OWrapSet [ ctor assoc comm id('empty.OWrapSet) ] .) (op '`(_`,_`) : 'OWrapSet 'ONat -> 'OWrapPolynomial [ ctor ] .) aac-wrapSorts(fmod H is IL sorts SS . SSDS OPDS MAS EQS endfm,SS) aac-wrapOps(processKinds(getEOpsByKind(fmod H is IL sorts SS . SSDS OPDS MAS EQS endfm, (none).KindOpDeclSetSet, OPDS))) (op '`(variable`,_`) : 'OWrap -> 'OTerm [ none ] .) (op '_>v_ : 'OTerm 'OTerm -> 'OBool [ none ] .) (op '_>=v_ : 'OTerm 'OTerm -> 'OBool [ none ] .) (op '_>v_ : 'OWrap 'OWrap -> 'OBool [ none ] .) (op '_>=v_ : 'OWrap 'OWrap -> 'OBool [ none ] .) (op '_>v`{lex`}_ : 'OWrapList 'OWrapList -> 'OBool [ none ] .) (op '_>>v_ : 'OWrapSet 'OWrapSet -> 'OBool [ none ] .) (op '_>>=v_ : 'OWrapSet 'OWrapSet -> 'OBool [ none ] .) (op '_>E_ : 'OWrap 'OWrap -> 'OBool [ none ] .) (op '_>=E_ : 'OWrap 'OWrap -> 'OBool [ none ] .) (op '_>E`{lex`}_ : 'OWrapList 'OWrapList -> 'OBool [ none ] .) (op '_>>E_ : 'OWrapSet 'OWrapSet -> 'OBool [ none ] .) (op '_>>=E_ : 'OWrapSet 'OWrapSet -> 'OBool [ none ] .) (op 'wrapToTerm : 'OWrap -> 'OTerm [ none ] .) (op 'acrpo5-1-set : 'OWrapSet 'OTerm -> 'OBool [ none ] .) (op 'acrpo5-1-list : 'OWrapList 'OTerm -> 'OBool [ none ] .) (op 'acrpo5-2-set : 'OTerm 'OWrapSet -> 'OBool [ none ] .) (op 'acrpo5-2-list : 'OTerm 'OWrapList -> 'OBool [ none ] .) (op 'sharp : 'OWrapSet 'ONat -> 'OWrapPolynomial [ none ] .) (op 'filter : 'OWrap 'OWrapSet -> 'OWrapSet [ none ] .) (op '_\_ : 'OWrapSet 'OWrapSet -> 'OWrapSet [ none ] .) (op 'size : 'OWrapSet -> 'ONat [ none ] .) (op '_>_ : 'OWrapPolynomial 'OWrapPolynomial -> 'OBool [ none ] .) (op '_>=_ : 'OWrapPolynomial 'OWrapPolynomial -> 'OBool [ none ] .) addACOpDecl(fmod H is IL sorts SS . SSDS OPDS MAS EQS endfm, OPDS) MAS (eq '_>v`{lex`}_['nil.OWrapList,'WL:OWrapList] = 'false.OBool [ none ] .) (eq '_>v`{lex`}_['__['W:OWrap,'WL:OWrapList],'nil.OWrapList] = 'true.OBool [ none ] .) (eq '_>v`{lex`}_['__['W1:OWrap,'WL1:OWrapList],'__['W2:OWrap,'WL2:OWrapList]] = '_or_['_>v_['wrapToTerm['W1:OWrap],'wrapToTerm['W2:OWrap]],'_and_['_==_['W1:OWrap,'W2:OWrap],'_>v`{lex`}_['WL1:OWrapList,'WL2:OWrapList]]] [ none ] .) (eq '_>>v_['empty.OWrapSet,'WS:OWrapSet] = 'false.OBool [ none ] .) (eq '_>>v_['_`,_['W:OWrap,'WS:OWrapSet],'empty.OWrapSet] = 'true.OBool [ none ] .) (eq '_>>v_['_`,_['W:OWrap,'WS1:OWrapSet],'_`,_['W:OWrap,'WS2:OWrapSet]] = '_>>v_['WS1:OWrapSet,'WS2:OWrapSet] [ none ] .) (eq '_>>v_['_`,_['W:OWrap,'WS1:OWrapSet],'WS2:OWrapSet] = '_>>=v_['WS1:OWrapSet,'filter['W:OWrap,'WS2:OWrapSet]] [ owise ] .) (eq 'acrpo5-1-set['empty.OWrapSet,'T:OTerm] = 'false.OBool [ none ] .) (eq 'acrpo5-1-set['_`,_['W:OWrap,'WS:OWrapSet],'T:OTerm] = '_or_['_>=v_['wrapToTerm['W:OWrap],'T:OTerm],'acrpo5-1-set['WS:OWrapSet,'T:OTerm]] [ none ] .) (eq 'acrpo5-1-list['nil.OWrapList,'T:OTerm] = 'false.OBool [ none ] .) (eq 'acrpo5-1-list['__['W:OWrap,'WL:OWrapList],'T:OTerm] = '_or_['_>=v_['wrapToTerm['W:OWrap],'T:OTerm],'acrpo5-1-list['WL:OWrapList,'T:OTerm]] [ none ] .) (eq 'acrpo5-2-set['T:OTerm,'empty.OWrapSet] = 'true.OBool [ none ] .) (eq 'acrpo5-2-set['T:OTerm,'_`,_['W:OWrap,'WS:OWrapSet]] = '_and_['_>v_['T:OTerm,'wrapToTerm['W:OWrap]],'acrpo5-2-set['T:OTerm,'WS:OWrapSet]] [ none ] .) (eq 'acrpo5-2-list['T:OTerm,'nil.OWrapList] = 'true.OBool [ none ] .) (eq 'acrpo5-2-list['T:OTerm,'__['W:OWrap,'WL:OWrapList]] = '_and_['_>v_['T:OTerm,'wrapToTerm['W:OWrap]],'acrpo5-2-list['T:OTerm,'WL:OWrapList]] [ none ] .) (eq '_>=v_['T1:OTerm,'T2:OTerm] = '_or_['_==_['T1:OTerm,'T2:OTerm],'_>v_['T1:OTerm,'T2:OTerm]] [ none ] .) (eq '_>=v_['W1:OWrap,'W2:OWrap] = '_or_['_==_['W1:OWrap,'W2:OWrap],'_>v_['W1:OWrap,'W2:OWrap]] [ none ] .) (eq '_>>=v_['WS1:OWrapSet,'WS2:OWrapSet] = '_or_['_==_['WS1:OWrapSet,'WS2:OWrapSet],'_>>v_['WS1:OWrapSet,'WS2:OWrapSet]] [ none ] .) (eq '_>E`{lex`}_['nil.OWrapList,'WL:OWrapList] = 'false.OBool [ none ] .) (eq '_>E`{lex`}_['__['W:OWrap,'WL:OWrapList],'nil.OWrapList] = 'true.OBool [ none ] .) (eq '_>E`{lex`}_['__['W1:OWrap,'WL1:OWrapList],'__['W2:OWrap,'WL2:OWrapList]] = '_or_['_>E_['W1:OWrap,'W2:OWrap],'_and_['_==_['W1:OWrap,'W2:OWrap],'_>E`{lex`}_['WL1:OWrapList,'WL2:OWrapList]]] [ none ] .) (eq '_>>E_['empty.OWrapSet,'WS:OWrapSet] = 'false.OBool [ none ] .) (eq '_>>E_['_`,_['W:OWrap,'WS:OWrapSet],'empty.OWrapSet] = 'true.OBool [ none ] .) (eq '_>>E_['_`,_['W:OWrap,'WS1:OWrapSet],'_`,_['W:OWrap,'WS2:OWrapSet]] = '_>>E_['WS1:OWrapSet,'WS2:OWrapSet] [ none ] .) (eq '_>>E_['_`,_['W:OWrap,'WS1:OWrapSet],'WS2:OWrapSet] = '_>>=E_['WS1:OWrapSet,'filter['W:OWrap,'WS2:OWrapSet]] [ owise ] .) (eq '_>=E_['W1:OWrap,'W2:OWrap] = '_or_['_==_['W1:OWrap,'W2:OWrap],'_>E_['W1:OWrap,'W2:OWrap]] [ none ] .) (eq '_>>=E_['WS1:OWrapSet,'WS2:OWrapSet] = '_or_['_==_['WS1:OWrapSet,'WS2:OWrapSet],'_>>E_['WS1:OWrapSet,'WS2:OWrapSet]] [ none ] .) (eq 'filter['W:OWrap,'empty.OWrapSet] = 'empty.OWrapSet [ none ] .) (eq 'filter['W1:OWrap,'_`,_['W2:OWrap,'WS:OWrapSet]] = 'if_then_else_fi['_>E_['W1:OWrap,'W2:OWrap],'filter['W1:OWrap,'WS:OWrapSet],'_`,_['W2:OWrap,'filter['W1:OWrap,'WS:OWrapSet]]] [ none ] .) (eq '_\_['_`,_['W:OWrap,'WS1:OWrapSet],'_`,_['W:OWrap,'WS2:OWrapSet]] = '_\_['WS1:OWrapSet,'WS2:OWrapSet] [ none ] .) (eq '_\_['WS1:OWrapSet,'WS2:OWrapSet] = 'WS1:OWrapSet [ owise ] .) (eq 'size['empty.OWrapSet] = '0.ONat [ none ] .) (eq 'size['_`,_['W:OWrap,'WS1:OWrapSet]] = 's_['size['WS1:OWrapSet]] [ none ] .) (eq '_>_['`(_`,_`)['WS1:OWrapSet,'N1:ONat],'`(_`,_`)['WS2:OWrapSet,'N2:ONat]] = '_and_['_==_['_\_['WS2:OWrapSet,'WS1:OWrapSet],'empty.OWrapSet],'_>_['_+_['size['_\_['WS1:OWrapSet,'WS2:OWrapSet]],'N1:ONat],'N2:ONat]] [ none ] .) (eq '_>=_['`(_`,_`)['WS1:OWrapSet,'N1:ONat],'`(_`,_`)['WS2:OWrapSet,'N2:ONat]] = '_and_['_==_['_\_['WS2:OWrapSet,'WS1:OWrapSet],'empty.OWrapSet],'_>=_['_+_['size['_\_['WS1:OWrapSet,'WS2:OWrapSet]],'N1:ONat],'N2:ONat]] [ none ] .) (eq '_>v_['W1:OWrap,'W2:OWrap] = '_>v_['wrapToTerm['W1:OWrap],'wrapToTerm['W2:OWrap]] [ none ] .) aac-wrapSortEqs(fmod H is IL sorts SS . SSDS OPDS MAS EQS endfm,SS) aac-wrapEqs(processKinds(getEOpsByKind(fmod H is IL sorts SS . SSDS OPDS MAS EQS endfm, none, OPDS))) aac-constrWrapEqs(fmod H is IL sorts SS . SSDS OPDS MAS EQS endfm, nil, sort(fromOpDeclSetToNatOpDeclList(addACOpDecl(fmod H is IL sorts SS . SSDS OPDS MAS EQS endfm, OPDS)))) endfm . op _>AAC{_}_ : Term Module Term -> Bool . eq T1 >AAC{ M } T2 = getTerm(metaReduce(aac-compWithOrd(M), '_>=E_['`[`[_`]`][T1],'`[`[_`]`][T2]])) == 'true.OBool . endfm -------------------------------------------------------------------------------- --- The above AAC-RPO code is a minimal, adapted version --- of the original AAC-RPO implemented by --- Raúl Gutiérrez -------------------------------------------------------------------------------- fmod NuITP-RPO is pr NuITP-AAC-RPO . pr NuITP-UTILS . pr NuITP-REMOVE-U . sorts OpDeclList OpDeclListTriple . subsort OpDecl < OpDeclList . var M : Module . vars LHS RHS : Term . var ODT : OpDeclListTriple . var OP : OpDecl . var OPDS : OpDeclSet . vars ODL ODL1 ODL2 ODL3 : OpDeclList . vars F F' : Qid . vars TYL TYL' : TypeList . vars TY TY' : TypeList . var N : Nat . vars ATS ATS' : AttrSet . vars STR STR' : String . var NeHL : NeHookList . op nil : -> OpDeclList [ ctor ] . op _,_ : OpDeclList OpDeclList -> OpDeclList [ ctor assoc id: nil ] . op _:_:_ : OpDeclList OpDeclList OpDeclList -> OpDeclListTriple [ ctor ] . op sortOps : Module -> Module . eq sortOps(M) = setOps(M, getSpecial(getOps(M)) sortOps(M, split(getOps(M)))) . op sortOps : Module OpDeclListTriple -> OpDeclSet . eq sortOps(M, ODL1 : ODL2 : ODL3) = sortOverloaded(M, sortOps(sortNat(ODL1) : sortSko(M, ODL2) : sortNat(ODL3), 1)) . op sortOverloaded : Module OpDeclSet -> OpDeclSet . ceq sortOverloaded(M, (op F : TYL -> TY [ ATS metadata(STR) ] .) (op F : TYL' -> TY' [ ATS' metadata(STR') ] .) OPDS) = sortOverloaded(M, (op F : TYL -> TY [ ATS metadata(STR) ] .) (op F : TYL' -> TY' [ ATS' metadata(STR) ] .) OPDS) if (sameKind(M, TY, TY')) /\ (rat(STR', 10) > rat(STR,10)) . eq sortOverloaded(M, OPDS) = OPDS [ owise ] . op sortOps : OpDeclListTriple Nat -> OpDeclSet . eq sortOps(nil : nil : nil , N) = none . eq sortOps(nil : nil : ((op F : TYL -> TY [ ATS metadata(STR) ] .) , ODL3), N) = (op F : TYL -> TY [ ATS metadata(string(N,10)) ] .) sortOps(nil : nil : ODL3, N + 1) . eq sortOps(nil : ((op F : TYL -> TY [ ATS metadata(STR) ] .) , ODL2) : ODL3, N) = (op F : TYL -> TY [ ATS metadata(string(N,10)) ] .) sortOps(nil : ODL2 : ODL3, N + 1) . eq sortOps(((op F : TYL -> TY [ ATS metadata(STR) ] .) , ODL1) : ODL2 : ODL3, N) = (op F : TYL -> TY [ ATS metadata(string(N,10)) ] .) sortOps(ODL1 : ODL2 : ODL3, N + 1) . op getSpecial : OpDeclSet -> OpDeclSet . eq getSpecial((op F : TYL -> TY [ ATS special(NeHL) ] .) OPDS) = (op F : TYL -> TY [ ATS special(NeHL) ] .) getSpecial(OPDS) . eq getSpecial(OPDS) = none [ owise ] . op split : OpDeclSet -> OpDeclListTriple . eq split((op F : TYL -> TY [ ATS special(NeHL) ] .) OPDS) = split(OPDS) . eq split(OPDS) = split(OPDS, nil : nil : nil) [ owise ] . op split : OpDeclSet OpDeclListTriple -> OpDeclListTriple . eq split(none, ODT) = ODT . eq split((op F : TYL -> TY [ ATS ctor ] .) OPDS, ODL1 : ODL2 : ODL3) = split(OPDS, (ODL1 , (op F : TYL -> TY [ fixMetadata(ATS) ctor ] .)) : ODL2 : ODL3) . eq split((op F : TYL -> TY [ ATS metadata("skolem") ] .) OPDS, ODL1 : ODL2 : ODL3) = split(OPDS, ODL1 : (ODL2 , (op F : TYL -> TY [ ATS metadata("skolem") ] .)) : ODL3) . eq split((op F : TYL -> TY [ ATS ] .) OPDS, ODL1 : ODL2 : ODL3) = split(OPDS, ODL1 : ODL2 : (ODL3 , (op F : TYL -> TY [ fixMetadata(ATS) ] .))) [ owise ] . op fixMetadata : AttrSet -> AttrSet . eq fixMetadata(ATS metadata(STR)) = ATS (if (rat(STR,10) :: Nat) then metadata(STR) else metadata("0") fi) . eq fixMetadata(ATS) = ATS metadata("0") [ owise ] . op sortNat : OpDeclList -> OpDeclList . ceq sortNat((ODL1 , (op F : TYL -> TY [ ATS metadata(STR) ] .) , ODL2 , (op F' : TYL' -> TY' [ ATS' metadata(STR') ] .) , ODL3)) = sortNat((ODL1 , (op F' : TYL' -> TY' [ ATS' metadata(STR') ] .) , ODL2 , (op F : TYL -> TY [ ATS metadata(STR) ] .) , ODL3)) if (rat(STR, 10) > rat(STR',10)) . eq sortNat(ODL) = ODL [ owise ] . op sortSko : Module OpDeclList -> OpDeclList . ceq sortSko(M, (ODL1 , (op F : TYL -> TY [ ATS ] .) , ODL2 , (op F' : TYL' -> TY' [ ATS' ] .) , ODL3)) = sortSko(M, (ODL1 , (op F' : TYL' -> TY' [ ATS' ] .) , ODL2 , (op F : TYL -> TY [ ATS ] .) , ODL3)) if sameKind(M, TY, TY') and-then not(sortLeq(M, TY, TY')) . eq sortSko(M, ODL) = ODL [ owise ] . op _>RPO{_}_ : Term Module Term -> Bool . eq LHS >RPO{ M } RHS = LHS >AAC{ removeU(sortOps(M)) } RHS . endfm fmod NuITP-CONG-CLOSURE-UTILS is pr NuITP-UTILS . sorts CCEquation CCEquationSet . subsort CCEquation < CCEquationSet . op _=e=_ : Term Term -> CCEquation [ ctor comm ] . op none : -> CCEquationSet [ ctor ] . op __ : CCEquationSet CCEquationSet -> CCEquationSet [ assoc comm id: none ] . eq E:CCEquation E:CCEquation = E:CCEquation . sorts CCRule CCRuleSet . subsort CCRule < CCRuleSet . op _=r=_ : Term Term -> CCRule [ ctor ] . op none : -> CCRuleSet [ ctor ] . op __ : CCRuleSet CCRuleSet -> CCRuleSet [ assoc comm id: none ] . eq R:CCRule R:CCRule = R:CCRule . sorts TermPair TermPairSet . subsort TermPair < TermPairSet . op mt : -> TermPairSet [ ctor ] . op {_:_} : Term Constant -> TermPair [ ctor ] . op __ : TermPairSet TermPairSet -> TermPairSet [ assoc comm id: mt ] . eq TP:TermPair TP:TermPair = TP:TermPair . sorts CCId CCIdList . subsort CCId < CCIdList . op nil : -> CCIdList [ ctor ] . op __ : CCIdList CCIdList -> CCIdList [ ctor assoc id: nil ] . sorts CongState CongState? . subsorts TermSet < CongState < CongState? . op error : -> CongState? [ ctor ] . op <_:_|_|_|_|_|_> : CCId Module TermPairSet CCEquationSet CCEquationSet CCRuleSet Nat -> CongState . vars T T' GAMMA : Term . var F : Qid . var NCTL : NeCTermList . var TL : TermList . var CO : Context . var TY : Type . var N : Nat . vars C C' : Constant . vars NTL NTL' : NeTermList . var M : Module . var Q : Qid . var H : Header . var IL : ImportList . var SS : SortSet . var SSDS : SubsortDeclSet . var OPDS : OpDeclSet . var MAS : MembAxSet . var EQS : EquationSet . var RLS : RuleSet . var STDS : StratDeclSet . var STDFS : StratDefSet . var K : TermPairSet . vars LHS RHS : Term . var ATS : AttrSet . var V : Variable . var CCEQ : CCEquation . var CCEQS : CCEquationSet . var CCRLS : CCRuleSet . var EQ : Equation . var NTS : NeTermSet . var TS : TermSet . op toCCEqs : EquationSet -> CCEquationSet . eq toCCEqs((none).EquationSet) = none . eq toCCEqs((eq LHS = RHS [ ATS] .)) = (LHS =e= RHS) . eq toCCEqs(EQ EQS) = toCCEqs(EQ) toCCEqs(EQS) . op toCCEqs : TermSet -> CCEquationSet . eq toCCEqs((mt).TermSet) = none . eq toCCEqs('true.NuITP-Bool) = none . eq toCCEqs('false.NuITP-Bool) = none . eq toCCEqs('_=_[LHS,RHS]) = (LHS =e= RHS) . eq toCCEqs('_=>_[LHS,RHS]) = (LHS =e= RHS) . eq toCCEqs('_->_['true.NuITP-Bool,'_=_[LHS,RHS]]) = (LHS =e= RHS) . eq toCCEqs('_->_['true.NuITP-Bool,'_=>_[LHS,RHS]]) = (LHS =e= RHS) . eq toCCEqs('_->_[GAMMA,'_=_[LHS,RHS]]) = (LHS =e= RHS) toCCEqs(GAMMA) [ owise ] . eq toCCEqs('_->_[GAMMA,'_=>_[LHS,RHS]]) = (LHS =e= RHS) toCCEqs(GAMMA) [ owise ] . eq toCCEqs(T ;; NTS) = toCCEqs(T) toCCEqs(NTS) . op _inCC_ : Term TermPairSet -> Bool . eq C inCC ({ T : C } K) = true . eq T inCC K = false [ owise ] . op ccFresh : Type Nat -> Constant . eq ccFresh(TY, N) = qid("CC#" + string(N, 10) + "." + substr(string(TY),0,length(string(TY)))) . op getCCSubTerms : TermList TermPairSet -> TermList . eq getCCSubTerms(empty, K) = empty . eq getCCSubTerms((C, TL), { T : C } K) = getCCSubTerms(TL, { T : C } K) . eq getCCSubTerms((C, TL), { C : C' } K) = getCCSubTerms(TL, { C : C' } K) . eq getCCSubTerms((C, TL), K) = C , getCCSubTerms(TL, K) [ owise ] . eq getCCSubTerms((F[NTL], TL), K) = (if allConstants(NTL, K) then F[NTL] else getCCSubTerms(NTL, K) fi) , getCCSubTerms(TL, K) . op allConstants : TermList TermPairSet -> Bool . eq allConstants(empty, K) = true . eq allConstants((C,TL), { T : C } K) = allConstants(TL, { T : C } K) . eq allConstants((T,TL), K) = false [ owise ] . op addConstant : Module Constant -> Module . eq addConstant(fmod H is IL sorts SS . SSDS OPDS MAS EQS endfm, C) = fmod H is IL sorts SS . SSDS OPDS (op getName(C) : nil -> getType(C) [ none ] .) MAS EQS endfm . eq addConstant(mod H is IL sorts SS . SSDS OPDS MAS EQS RLS endm, C) = mod H is IL sorts SS . SSDS OPDS (op getName(C) : nil -> getType(C) [ none ] .) MAS EQS RLS endm . eq addConstant(smod H is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm, C) = smod H is IL sorts SS . SSDS OPDS (op getName(C) : nil -> getType(C) [ none ] .) MAS EQS RLS STDS STDFS endsm . eq addConstant(fth Q is IL sorts SS . SSDS OPDS MAS EQS endfth, C) = fth Q is IL sorts SS . SSDS OPDS (op getName(C) : nil -> getType(C) [ none ] .) MAS EQS endfth . eq addConstant(th Q is IL sorts SS . SSDS OPDS MAS EQS RLS endth, C) = th Q is IL sorts SS . SSDS OPDS (op getName(C) : nil -> getType(C) [ none ] .) MAS EQS RLS endth . eq addConstant(sth Q is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth, C) = sth Q is IL sorts SS . SSDS OPDS (op getName(C) : nil -> getType(C) [ none ] .) MAS EQS RLS STDS STDFS endsth . op replaceConstant : Constant Constant CCEquationSet -> CCEquationSet . eq replaceConstant(C, C', (none).CCEquationSet) = none . eq replaceConstant(C, C', (LHS =e= RHS) CCEQS) = (replaceConstant(C, C', LHS) =e= replaceConstant(C, C', RHS)) replaceConstant(C, C', CCEQS) . op replaceConstant : Constant Constant CCRuleSet -> CCRuleSet . eq replaceConstant(C, C', (none).CCRuleSet) = none . eq replaceConstant(C, C', (LHS =r= RHS) CCRLS) = (replaceConstant(C, C', LHS) =r= replaceConstant(C, C', RHS)) replaceConstant(C, C', CCRLS) . op replaceConstant : Constant Constant TermList -> TermList . op replaceConstant : Constant Constant Term -> Term . eq replaceConstant(C, C', empty) = empty . eq replaceConstant(C, C', C) = C' . eq replaceConstant(C, C', F[NTL]) = F[replaceConstant(C, C', NTL)] . eq replaceConstant(C, C', (T,NTL)) = replaceConstant(C, C', T) , replaceConstant(C, C', NTL) . eq replaceConstant(C, C', T) = T [ owise ] . op revert : TermPairSet CCRuleSet -> TermSet . eq revert(K, (none).CCRuleSet) = mt . eq revert(K, (LHS =r= RHS) CCRLS) = ('_->_['true.NuITP-Bool,'_=>_[revert(K, LHS),revert(K, RHS)]]) ;; revert(K, CCRLS) . op revert : TermPairSet TermList -> TermList . eq revert(K, empty) = empty . eq revert(K { T : C }, C) = revert(K, T) . eq revert(K, F[NTL]) = F[revert(K, NTL)] . eq revert(K, (T,NTL)) = revert(K, T) , revert(K, NTL) . eq revert(K, T) = T [ owise ] . op cleanCCRule : TermSet -> TermSet . eq cleanCCRule(('_->_['true.NuITP-Bool,'_=>_[LHS,LHS]]) ;; TS) = cleanCCRule(TS) . eq cleanCCRule(('true.NuITP-Bool) ;; TS) = cleanCCRule(TS) . eq cleanCCRule(TS) = TS [ owise ] . op isAEquation : Module CCEquation TermPairSet -> Bool . eq isAEquation(M, (F[NTL] =e= F[NTL']), K) = isAEquation((getTerm(metaNormalize(M, F[NTL])) =e= getTerm(metaNormalize(M, F[NTL']))),K) . --- TODO: check F is AC? eq isAEquation(M, CCEQ, K) = false [ owise ] . op isAEquation : CCEquation TermPairSet -> Bool . eq isAEquation((F[NTL] =e= F[NTL']), K) = isDEquation(NTL,K) and-then isDEquation(NTL',K) . eq isAEquation(CCEQ, K) = false [ owise ] . op isCEquation : CCEquation TermPairSet -> Bool . eq isCEquation((LHS =e= RHS), K) = (LHS inCC K) and-then (RHS inCC K) . op isDEquation : CCEquation TermPairSet -> Bool . eq isDEquation((C =e= C'), ({ T : C' } K)) = not (C inCC K) . eq isDEquation((F[NTL] =e= C), ({ T : C } K)) = isDEquation(NTL,K) . eq isDEquation(CCEQ, K) = false [ owise ] . op isDEquation : TermList TermPairSet -> Bool . eq isDEquation(empty, K) = true . eq isDEquation(C, ({ T : C } K)) = true . eq isDEquation(T, K) = false [ owise ] . eq isDEquation((T, NTL), K) = isDEquation(T, K) and-then isDEquation(NTL,K) . endfm fmod NuITP-CONG-CLOSURE is pr NuITP-CONG-CLOSURE-UTILS . pr NuITP-RPO . vars K K' : TermPairSet . vars C C' D : Constant . vars M M' : Module . var EQS EQS' NOW NOW' : CCEquationSet . var RLS RLS' : CCRuleSet . var EQ : CCEquation . vars LHS RHS LHS' RHS' T : Term . var CO : Context . var SB : Substitution . vars N N' : Nat . var TL : TermList . vars F RULE : Qid . var NTL : NeTermList . var NTS : NeTermSet . vars RID RID' : CCId . vars RIL : CCIdList . ops pick sim ext del ori col ded compo compr : -> CCId [ ctor ] . eq [pick] : < pick : M | K | none | (LHS =e= RHS) EQS | RLS | N > = < nil : M | K | (LHS =e= RHS) | EQS | RLS | N > . eq [end*] : < RID RIL : M | K | NOW | EQS | RLS | N > = < RIL : M | K | NOW | EQS | RLS | N > [ owise ] . --- Simplification ceq [sim] : < sim RIL : M | K | (LHS =e= RHS) | EQS | RLS (LHS' =r= C) | N > = < sim RIL : M | K | (getTerm(metaNormalize(M, replaceHole(CO, C))) =e= RHS) | EQS | RLS (LHS' =r= C) | N > if (getTerm(metaNormalize(M, LHS)) =/= getTerm(metaNormalize(M, RHS))) /\ { SB , CO } := metaXmatch(M, LHS', LHS, nil, 0, unbounded, 0) . --- Extension ceq [ext] : < ext RIL : M | K | (LHS =e= RHS) | EQS | RLS | N > = < ext RIL : addConstant(M, ccFresh(getType(metaNormalize(M, T)), N)) | (K { T : ccFresh(getType(metaNormalize(M, T)), N) }) | (getTerm(metaNormalize(addConstant(M, ccFresh(getType(metaNormalize(M, T)), N)), replaceHole(CO, ccFresh(getType(metaNormalize(M, T)), N)))) =e= RHS) | EQS | RLS (T =r= ccFresh(getType(metaNormalize(M, T)), N)) | N + 1 > if (getTerm(metaNormalize(M, LHS)) =/= getTerm(metaNormalize(M, RHS))) /\ not(isDEquation((LHS =e= RHS), K)) /\ not(isAEquation(M, (LHS =e= RHS), K)) /\ (T , TL) := getCCSubTerms(LHS, K) /\ not(T inCC K) /\ isDEquation((T =e= ccFresh(getType(metaNormalize(M, T)), N)), (K { T : ccFresh(getType(metaNormalize(M, T)), N) })) /\ { SB , CO } := metaXmatch(M, T, LHS, nil, 0, unbounded, 0) . --- Deletion ceq [del] : < del RIL : M | K | (LHS =e= RHS) | EQS | RLS | N > = < del RIL : M | K | none | EQS | RLS | N > if (getTerm(metaNormalize(M, LHS)) == getTerm(metaNormalize(M, RHS))) . --- Orientation ceq [ori] : < ori RIL : M | K | (LHS =e= RHS) | EQS | RLS | N > = if (revert(K, RHS) >RPO{ M } revert(K, LHS)) then < ori RIL : M | K | none | EQS | RLS (RHS =r= LHS) | N > else < ori RIL : M | K | none | EQS | RLS (LHS =r= RHS) | N > fi if isCEquation((LHS =e= RHS), K) or-else isDEquation((LHS =e= RHS), K) or-else isAEquation(M, (LHS =e= RHS), K) /\ (getTerm(metaNormalize(M, LHS)) =/= getTerm(metaNormalize(M, RHS))) . --- Collapse ceq [col] : < col RIL : M | K | none | EQS | RLS (LHS =r= C') (C =r= D) | N > = < col RIL : M | K | none | EQS | RLS (getTerm(metaNormalize(M, replaceHole(CO, D))) =r= C') (C =r= D) | N > if { SB , CO } := metaXmatch(M, C, LHS, nil, 0, unbounded, 0) . --- Deduction eq [ded] : < ded RIL : M | K | none | EQS | RLS (LHS =r= C) (LHS =r= D) | N > = < ded RIL : M | K | (C =e= D) | EQS | RLS (LHS =r= D) | N > . --- Composition eq [compo] : < compo RIL : M | K | none | EQS | RLS (LHS =r= C) (C =r= D) | N > = < compo RIL : M | K | none | EQS | RLS (LHS =r= D) (C =r= D) | N > . --- Compression eq [compr] : < compr RIL : M | K { T : C } { T : D } | none | EQS | RLS (C =r= D) | N > = < compr RIL : M | K { T : D } | none | replaceConstant(C, D, EQS) | replaceConstant(C, D, RLS) | N > . op solve : CongState -> TermSet . eq solve(< nil : M | K | NOW | none | RLS | N >) = cleanCCRule(revert(K, RLS)) . eq solve(< nil : M | K | none | EQS | RLS | N >) = solve(step0*(< nil : M | K | none | EQS | RLS | N >, < pick : M | K | none | EQS | RLS | N >)) [ owise ] . op step0* : CongState CongState -> CongState . eq step0*(< nil : M | K | NOW | EQS | RLS | N >, < nil : M' | K | NOW | EQS | RLS | N >) = < nil : M | K | NOW | EQS | RLS | N > . eq step0*(< nil : M | K | NOW | EQS | RLS | N >, < nil : M' | K' | NOW' | EQS' | RLS' | N' >) = step0*(< nil : M' | K' | NOW' | EQS' | RLS' | N' >, step1*(< nil : M' | K' | NOW' | EQS' | RLS' | N' >, < sim ext : M' | K' | NOW' | EQS' | RLS' | N' >)) [ owise ] . op step1* : CongState CongState -> CongState . eq step1*(< nil : M | K | NOW | EQS | RLS | N >, < nil : M' | K | NOW | EQS | RLS | N >) = step2*(< nil : M | K | NOW | EQS | RLS | N >, < del ori compr col compo ded sim : M | K | NOW | EQS | RLS | N >) . eq step1*(< nil : M | K | NOW | EQS | RLS | N >, < nil : M' | K' | NOW' | EQS' | RLS' | N' >) = step1*(< nil : M' | K' | NOW' | EQS' | RLS' | N' >, < sim ext : M' | K' | NOW' | EQS' | RLS' | N' >) [ owise ] . op step2* : CongState CongState -> CongState . eq step2*(< nil : M | K | NOW | EQS | RLS | N >, < nil : M' | K | NOW | EQS | RLS | N >) = < nil : M | K | NOW | EQS | RLS | N > . eq step2*(< nil : M | K | NOW | EQS | RLS | N >, < nil : M' | K' | NOW' | EQS' | RLS' | N' >) = step2*(< nil : M' | K' | NOW' | EQS' | RLS' | N' >, < del ori compr col compo ded sim : M' | K' | NOW' | EQS' | RLS' | N' >) [ owise ] . op cong-closure : Module -> TermSet . eq cong-closure(M) = if (getEqs(M) =/= none) then solve(< nil : M | mt | none | toCCEqs(getEqs(M)) | none | 0 >) else mt fi . op cong-closure : Module TermSet -> TermSet . eq cong-closure(M, mt) = mt . eq cong-closure(M, NTS) = solve(< nil : M | mt | none | toCCEqs(NTS) | none | 0 >) . endfm fmod NuITP-HSIMP is pr NuITP-EQPREDS . pr NuITP-REMOVE-U . pr NuITP-RPO . pr NuITP-CONG-CLOSURE . var M : Module . var N : Nat . vars LHS RHS T T1 T2 GAMMA#i GAMMA LAMBDA EQ : Term . vars HPS CLS CLS' EQS EQS' TS CLA SKO HGE HE HNE : TermSet . var OPDS : OpDeclSet . var NTS : NeTermSet . var NTL : NeTermList . var TL : TermList . op [_|_|_] : TermSet TermSet TermSet -> ResultTriple [ ctor ] . op getHGE : ResultTriple -> TermSet . eq getHGE([ HGE | HE | HNE ]) = HGE . op getHE : ResultTriple -> TermSet . eq getHE([ HGE | HE | HNE ]) = HE . op getHNE : ResultTriple -> TermSet . eq getHNE([ HGE | HE | HNE ]) = HNE . op hgeu : TermSet -> TermSet . eq hgeu(mt) = mt . eq hgeu(NTS) = getHGE(hClassify(NTS)) . op heu++ : TermSet -> TermSet . eq heu++(mt) = mt . eq heu++(NTS) = getHE(hClassify(NTS)) . --- Executables op heu+ : TermSet -> TermSet . eq heu+(mt) = mt . eq heu+(NTS) = getHE(hClassify(NTS)) ;; getHGE(hClassify(NTS)) . --- Non-executables op hne : TermSet -> TermSet . eq hne(mt) = mt . eq hne(NTS) = getHNE(hClassify(NTS)) . --- Ground eqs are always orientable due to total ordering. op orient : Module TermList -> TermList . op orient : Module TermSet -> TermSet . op orient : Module Term -> Term . eq orient(M, empty) = empty . eq orient(M, mt) = mt . eq orient(M, '_->_[GAMMA,LAMBDA]) = '_->_[GAMMA,orient(M, LAMBDA)] . eq orient(M, '_=>_[LHS,RHS]) = '_=>_[LHS,RHS] . eq orient(M, '_=_[LHS,RHS]) = (if (LHS >RPO{ M } RHS) then '_=>_[LHS,RHS] else if (RHS >RPO{ M } LHS) then '_=>_[RHS,LHS] else '_=_[LHS,RHS] fi fi) . eq orient(M, '_\/_[NTL]) = '_\/_[orient(M, NTL)] . eq orient(M, '_/\_[NTL]) = '_/\_[orient(M, NTL)] . eq orient(M, (T,NTL)) = orient(M,T) , orient(M,NTL) . eq orient(M, (T ;; NTS)) = orient(M,T) ;; orient(M,NTS) . eq orient(M, T) = T [ owise ] . op eu : Module -> Module . eq eu(M) = removeU(M) . op euR : Module -> Module . eq euR(M) = setRls(setEqs(M, (none).EquationSet), toRls(getEqs(removeU(M)), 0)) . op e=xu : Module TermSet -> Module . eq e=xu(M, SKO) = addOps(eqPreds(removeU(M)),toOps(SKO)) . op hClassify : TermSet -> ResultTriple . eq hClassify(mt) = [ mt | mt | mt ] . eq hClassify(NTS) = hClassify(NTS, [ mt | mt | mt ]) . op hClassify : NeTermSet ResultTriple -> ResultTriple . eq hClassify('_->_['true.NuITP-Bool,'_=_[LHS,RHS]], [ HGE | HE | HNE ]) = [ HGE | HE | (HNE ;; ('_->_['true.NuITP-Bool,'_=_[LHS,RHS]])) ] . eq hClassify('_->_['true.NuITP-Bool,'_=>_[LHS,RHS]], [ HGE | HE | HNE ]) = if ('_=>_[LHS,RHS] :: GroundTerm) then [ (HGE ;; ('_->_['true.NuITP-Bool,'_=>_[LHS,RHS]])) | HE | HNE ] else if (getVars(RHS) in getVars(LHS)) then [ HGE | (HE ;; ('_->_['true.NuITP-Bool,'_=>_[LHS,RHS]])) | HNE ] else [ HGE | HE | (HNE ;; ('_->_['true.NuITP-Bool,'_=>_[LHS,RHS]])) ] fi fi . eq hClassify('_->_[GAMMA,'_=_[LHS,RHS]], [ HGE | HE | HNE ]) = [ HGE | HE | (HNE ;; ('_->_[GAMMA,'_=_[LHS,RHS]])) ] [ owise ] . eq hClassify('_->_[GAMMA,'_=>_[LHS,RHS]], [ HGE | HE | HNE ]) = if (getVars(RHS) in getVars(LHS)) and-then (getVars(GAMMA) in getVars(LHS)) then [ HGE | (HE ;; ('_->_[GAMMA,'_=>_[LHS,RHS]])) | HNE ] else [ HGE | HE | (HNE ;; ('_->_[GAMMA,'_=>_[LHS,RHS]])) ] fi [ owise ] . eq hClassify(('_->_['true.NuITP-Bool,'_=_[LHS,RHS]]) ;; NTS, [ HGE | HE | HNE ]) = hClassify(NTS, [ HGE | HE | (HNE ;; ('_->_['true.NuITP-Bool,'_=_[LHS,RHS]])) ]) . eq hClassify(('_->_['true.NuITP-Bool,'_=>_[LHS,RHS]]) ;; NTS, [ HGE | HE | HNE ]) = if ('_=>_[LHS,RHS] :: GroundTerm) then hClassify(NTS, [ (HGE ;; ('_->_['true.NuITP-Bool,'_=>_[LHS,RHS]])) | HE | HNE ]) else if (getVars(RHS) in getVars(LHS)) then hClassify(NTS, [ HGE | (HE ;; ('_->_['true.NuITP-Bool,'_=>_[LHS,RHS]])) | HNE ]) else hClassify(NTS, [ HGE | HE | (HNE ;; ('_->_['true.NuITP-Bool,'_=>_[LHS,RHS]])) ]) fi fi . eq hClassify(('_->_[GAMMA,'_=_[LHS,RHS]]) ;; NTS, [ HGE | HE | HNE ]) = hClassify(NTS, [ HGE | HE | (HNE ;; ('_->_[GAMMA,'_=_[LHS,RHS]])) ]) [ owise ] . eq hClassify(('_->_[GAMMA,'_=>_[LHS,RHS]]) ;; NTS, [ HGE | HE | HNE ]) = if (getVars(RHS) in getVars(LHS)) and-then (getVars(GAMMA) in getVars(LHS)) then hClassify(NTS, [ HGE | (HE ;; ('_->_[GAMMA,'_=>_[LHS,RHS]])) | HNE ]) else hClassify(NTS, [ HGE | HE | (HNE ;; ('_->_[GAMMA,'_=>_[LHS,RHS]])) ]) fi [ owise ] . op hsimp : Module TermSet TermSet -> TermSet . eq hsimp(M, SKO, mt) = mt . eq hsimp(M, SKO, NTS) = hsimp'( e=xu(M, SKO), hsimp''( addOps(M, SKO), hClassify(orient(addOps(M, SKO), hsimp'(e=xu(M, SKO), NTS))) ) ) . op hsimp' : Module NeTermSet -> TermSet . eq hsimp'(M, mt) = mt . eq hsimp'(M, T) = if (T == 'true.NuITP-Bool) then mt else getTerm(metaReduce(M, T)) fi . eq hsimp'(M, T ;; NTS) = hsimp'(M, T) ;; hsimp'(M, NTS) . op hsimp'' : Module ResultTriple -> TermSet . eq hsimp''(M, [ HGE | HE | HNE ]) = h''ge(M, HGE) ;; h''e++(addEqs(M, h''ge(M, HGE)), HE) ;; h''ne(addEqs(M, h''ge(M, HGE)), HNE) . op h''ge : Module TermSet -> TermSet . eq h''ge(M, mt) = mt . eq h''ge(M, NTS) = cong-closure(M, NTS) . --- TODO: Congruence Closure + Normalization op h''e++ : Module TermSet -> TermSet . eq h''e++(M, mt) = mt . eq h''e++(M, T) = getTerm(metaReduce(M, T)) . eq h''e++(M, T ;; NTS) = getTerm(metaReduce(M, T)) ;; h''e++(M, NTS) . op h''ne : Module TermSet -> TermSet . eq h''ne(M, mt) = mt . eq h''ne(M, T) = getTerm(metaReduce(M, T)) . eq h''ne(M, T ;; NTS) = h''ne(M, T) ;; h''ne(M, NTS) . op oriented? : TermList -> Bool . eq oriented?(empty) = true . eq oriented?('true.NuITP-Bool) = true . eq oriented?('false.NuITP-Bool) = true . eq oriented?('_=_[LHS,RHS]) = false . eq oriented?('_=>_[LHS,RHS]) = true . eq oriented?('_/\_[NTL]) = oriented?(NTL) . eq oriented?('_\/_[NTL]) = oriented?(NTL) . eq oriented?('_->_[GAMMA,LAMBDA]) = oriented?(LAMBDA) . eq oriented?((T,TL)) = oriented?(T) and-then oriented?(TL) [ owise ] . endfm fmod NuITP-CONSTRUCTOR is pr NuITP-UTILS . var M : Module . vars T T' LHS RHS : Term . var N : Nat . vars S S' : Sort . vars TY TY' : Type . var TYL : TypeList . var F : Qid . var OPD : OpDecl . var ATS : AttrSet . var C : Constant . var V : Variable . var TL : TermList . var COND : Condition . var QS : TermSet . var SB : Substitution . var H : Header . var IL : ImportList . var SS : SortSet . var SSDS : SubsortDeclSet . var OPDS : OpDeclSet . var MAS : MembAxSet . var EQS : EquationSet . var RLS : RuleSet . var K : Kind . var KS : KindSet . var STR : String . op auxModule : Module -> Module . eq auxModule(M) = addEqs(addOps(addSubSorts(addSubSorts(addSorts(M,auxSorts(getSorts(M) ; 'NuITP-Bool)),auxSubSorts(getSubsorts(M))),auxSubSorts'(getSorts(M) ; 'NuITP-Bool)), auxOps(getOps(M)) (op 'NuITP-tt : nil -> 'NuITP-Bool [ ctor ] .) (op '_=?=_ : 'Universal 'Universal -> '`[NuITP-Bool`] [ ctor poly (1 2) ] .)),auxEqs(auxSorts(getSorts(M) ; 'NuITP-Bool))) . op auxEqs : SortSet -> EquationSet . eq auxEqs(none) = none . eq auxEqs(S ; SS) = (eq '_=?=_[qid("X:" + cleanString(S)),qid("X:" + cleanString(S))] = 'NuITP-tt.NuITP-Bool [ label('unif) variant ] .) auxEqs(SS) . op auxSorts : SortSet -> SortSet . eq auxSorts(none) = none . eq auxSorts(S ; SS) = qid("#" + string(S)) ; auxSorts(SS) [ owise ] . op auxSubSorts : SubsortDeclSet -> SubsortDeclSet . eq auxSubSorts(none) = none . eq auxSubSorts((subsort S < S' .) SSDS) = (subsort qid("#" + string(S)) < qid("#" + string(S')) .) auxSubSorts(SSDS) . op auxSubSorts' : SortSet -> SubsortDeclSet . eq auxSubSorts'(none) = none . eq auxSubSorts'(S ; SS) = (subsort qid("#" + string(S)) < S .) auxSubSorts'(SS) . op auxTypes : TypeList -> TypeList . eq auxTypes(nil) = nil . eq auxTypes(TY TYL) = if ((substr(string(TY),0,2)) == "`[") then qid("`[#" + substr(string(TY),2,length(string(TY)))) auxTypes(TYL) else qid("#" + string(TY)) auxTypes(TYL) fi . op auxOps : OpDeclSet -> OpDeclSet . eq auxOps(none) = none . eq auxOps((op F : TYL -> TY [ ctor ATS ] .) OPDS) = (op F : auxTypes(TYL) -> auxTypes(TY) [ ctor ATS ] .) auxOps(OPDS) . eq auxOps(OPD OPDS) = auxOps(OPDS) [ owise ] . op restoreSorts : Substitution -> Substitution . eq restoreSorts((none).Substitution) = none . eq restoreSorts(V <- T ; SB) = restoreSorts(V) <- restoreSorts(T) ; restoreSorts(SB) [ owise ] . op restoreSorts : Term -> Term . eq restoreSorts(C) = if (substr(string(getType(C)),0,1) == "#") then qid(string(getName(C)) + "." + substr(string(getType(C)),1,length(string(getType(C))))) else C fi . eq restoreSorts(V) = if (substr(string(getType(V)),0,1) == "#") then qid(string(getName(V)) + ":" + substr(string(getType(V)),1,length(string(getType(V))))) else V fi . eq restoreSorts(F[TL]) = F[restoreSorts'(TL)] . op restoreSorts' : TermList -> TermList . eq restoreSorts'(empty) = empty . eq restoreSorts'((T,TL)) = (restoreSorts(T),restoreSorts'(TL)) . op getCUnifiers : Module Term Term -> SubstitutionSet . eq getCUnifiers(M,T,T') = getCUnifiers(auxModule(M),'_=?=_[T,T'],'NuITP-tt.NuITP-Bool,0) . op getCUnifiers : Module Term Term Nat -> SubstitutionSet . eq getCUnifiers(M,T,T',N) = if (metaVariantUnify(M, T =? T', empty, '#, filter delay, N) :: UnificationPair) then restoreSorts(getSubstitution(metaVariantUnify(M, T =? T', empty, '#, filter delay, N))) | getCUnifiers(M,T,T',s(N)) else mt fi . endfm mod NuITP-SIMPLIFICATION-RULES is pr NuITP-STATE . pr NuITP-HSIMP . pr NuITP-SKOLEM . pr NuITP-CONSTRUCTOR . pr NuITP-CONG-CLOSURE . var B : Bool . vars F F' RID : Qid . vars N N' : Nat . vars M MR : Module . var G : Goal . vars GS GS' GOALS : GoalSet . var C : Constant . var V : Variable . vars T T' HP HP' CL CLA CLA' GAMMA GAMMA#i LAMBDA LAMBDA' LAMBDAi LHS RHS TV TU : Term . vars SKO SKO' HPS TS SKTV GAMMA#! GAMMA# : TermSet . vars TL TL' TUL TVL : TermList . vars CO CO' : Context . var NTL : NeTermList . vars NTS NTS' : NeTermSet . vars SB SB1 SB2 SB3 ALPHA : Substitution . var SBS : SubstitutionSet . vars ID STR : String . var TY : Type . var TYL : TypeList . var LOG : StringList . op apply! : Module GoalSet -> GoalSet . eq apply!(M, mt) = mt . eq apply!(M, { ID, RID, SKO, HPS, CLA }) = eps(addRls(e=xu(M, SKO), heu+(HPS)), { ID, RID, SKO, HPS, CLA }, CLA, 0, false) . eq apply!(M, G GS ) = apply!(M, G) apply!(M, GS) [ owise ] . --- Equality Predicate Simplification (EPS) rl [eps] : M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS' => M | LOG | GS { ID, RID, SKO, HPS, CLA } | GS' eps(addRls(e=xu(M, SKO), heu+(HPS)), { ID, RID, SKO, HPS, CLA }, CLA, 0, true) . --- Manual version with new ids generated op eps : Module Goal Term Nat Bool -> GoalSet . eq eps(M, { ID, RID, SKO, HPS, CLA }, CLA', N, true) = if (metaSearch(M, CLA, 'RES:`[NuITP-Bool`], nil, '!, unbounded, N) :: ResultTriple) then if (getTerm(metaSearch(M, CLA, 'RES:`[NuITP-Bool`], nil, '!, unbounded, N)) == 'true.NuITP-Bool) then { ID + ".1", 'EPS, SKO, HPS, 'true.NuITP-Bool } else if (getTerm(metaSearch(M, CLA, 'RES:`[NuITP-Bool`], nil, '!, unbounded, N)) == 'false.NuITP-Bool) then { ID + ".1", 'EPS, SKO, HPS, 'false.NuITP-Bool } else eps(M, { ID, RID, SKO, HPS, CLA }, getTerm(metaSearch(M, CLA, 'RES:`[NuITP-Bool`], nil, '!, unbounded, N)), N + 1, true) fi fi else { ID + ".1", 'EPS, SKO, HPS, CLA' } fi . --- Automated ! version that preserves the given goal id eq eps(M, { ID, RID, SKO, HPS, CLA }, CLA', N, false) = if (metaSearch(M, CLA, 'RES:`[NuITP-Bool`], nil, '!, unbounded, N) :: ResultTriple) then if (getTerm(metaSearch(M, CLA, 'RES:`[NuITP-Bool`], nil, '!, unbounded, N)) == 'true.NuITP-Bool) then { ID, qid(string(RID) + "!"), SKO, HPS, 'true.NuITP-Bool } else if (getTerm(metaSearch(M, CLA, 'RES:`[NuITP-Bool`], nil, '!, unbounded, N)) == 'false.NuITP-Bool) then { ID, qid(string(RID) + "!"), SKO, HPS, 'false.NuITP-Bool } else eps(M, { ID, RID, SKO, HPS, CLA }, getTerm(metaSearch(M, CLA, 'RES:`[NuITP-Bool`], nil, '!, unbounded, N)), N + 1, false) fi fi else { ID, qid(string(RID) + "!"), SKO, HPS, CLA' } fi . --- Constructor Variant Unification Left (CVUL) crl [cvul] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_['_=_[LHS,RHS],LAMBDA] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_['_=_[LHS,RHS],LAMBDA] } | GS' if (getCUnifiers(M, unfreeze(LHS,SKO),unfreeze(RHS,SKO)) == mt) then { ID + ".1", 'CVUL, SKO, HPS, 'true.NuITP-Bool } else cvul(M, { ID, RID, SKO, HPS, '_->_['_=_[LHS,RHS],LAMBDA] }, '_=_[LHS,RHS], 1, skvars('_=_[LHS,RHS],SKO), getCUnifiers(M, unfreeze(LHS,SKO),unfreeze(RHS,SKO))) fi if isSigma1?(addOps(M,SKO), '_=_[LHS,RHS]) . crl [cvul] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[LHS,RHS],TL'],LAMBDA] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[LHS,RHS],TL'],LAMBDA] } | GS' if (getCUnifiers(M, unfreeze(LHS,SKO),unfreeze(RHS,SKO)) == mt) then { ID + ".1", 'CVUL, SKO, HPS, 'true.NuITP-Bool } else cvul(M, { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[LHS,RHS],TL'],LAMBDA] }, '_=_[LHS,RHS], 1, skvars('_=_[LHS,RHS],SKO), getCUnifiers(M, unfreeze(LHS,SKO),unfreeze(RHS,SKO))) fi if isSigma1?(addOps(M,SKO), '_=_[LHS,RHS]) . op cvul : Module Goal Term Nat TermSet SubstitutionSet -> GoalSet . eq cvul(M, { ID, RID, SKO, HPS, '_->_['_=_[LHS,RHS],LAMBDA] },'_=_[LHS,RHS],N,TS,mt) = mt . eq cvul(M, { ID, RID, SKO, HPS, '_->_['_=_[LHS,RHS],LAMBDA] },'_=_[LHS,RHS],N,TS,SB | SBS) = { ID + "." + string(N,10), 'CVUL, SKO ;; freeze(getVars(applySub(TS,safeVars(SB,ID + "." + string(N,10))))), hsimp( M, SKO ;; freeze(getVars(applySub(TS,safeVars(SB,ID + "." + string(N,10))))), HPS ;; cvul'(SKO ;; freeze(getVars(applySub(TS,safeVars(SB,ID + "." + string(N,10))))), TS, freeze(safeVars(SB,ID + "." + string(N,10)),getVars(applySub(TS,safeVars(SB,ID + "." + string(N,10)))))) ), getTerm(metaReduce( redModule(M, SKO ;; freeze(getVars(applySub(TS,safeVars(SB,ID + "." + string(N,10)))))), applySub(unfreeze('_->_['true.NuITP-Bool,LAMBDA],SKO),freeze(safeVars(SB,ID + "." + string(N,10)),getVars(applySub(TS,safeVars(SB,ID + "." + string(N,10)))))) )) } cvul(M, { ID, RID, SKO, HPS, '_->_['_=_[LHS,RHS],LAMBDA] }, '_=_[LHS,RHS], N + 1, TS, SBS) . eq cvul(M, { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[LHS,RHS],TL'],LAMBDA] },'_=_[LHS,RHS],N,TS,mt) = mt . eq cvul(M, { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[LHS,RHS],TL'],LAMBDA] },'_=_[LHS,RHS],N,TS,SB | SBS) = { ID + "." + string(N,10), 'CVUL, SKO ;; freeze(getVars(applySub(TS,safeVars(SB,ID + "." + string(N,10)))) ;; getRanVars(safeVars(SB,ID + "." + string(N,10)))), hsimp( M, SKO ;; freeze(getVars(applySub(TS,safeVars(SB,ID + "." + string(N,10))) ;; getRanVars(safeVars(SB,ID + "." + string(N,10))))), HPS ;; cvul'(SKO ;; freeze(getVars(applySub(TS,safeVars(SB,ID + "." + string(N,10)))) ;; getRanVars(safeVars(SB,ID + "." + string(N,10)))), TS, freeze(safeVars(SB,ID + "." + string(N,10)),getVars(applySub(TS,safeVars(SB,ID + "." + string(N,10)))))) ), getTerm(metaReduce( redModule(M, SKO ;; freeze(getVars(applySub(TS,safeVars(SB,ID + "." + string(N,10)))) ;; getRanVars(safeVars(SB,ID + "." + string(N,10))))), applySub(unfreeze('_->_[getTerm(metaNormalize(addOps(M, SKO ;; freeze(getVars(applySub(TS,safeVars(SB,ID + "." + string(N,10)))))),'_/\_[TL,'true.NuITP-Bool,TL'])),LAMBDA],SKO),freeze(safeVars(SB,ID + "." + string(N,10)),getVars(applySub(TS,safeVars(SB,ID + "." + string(N,10)))))) )) } cvul(M, { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[LHS,RHS],TL'],LAMBDA] },'_=_[LHS,RHS],s(N),TS,SBS) . op cvul' : TermSet TermSet Substitution -> TermSet . eq cvul'(SKO, mt, SB) = mt . eq cvul'(SKO, TS, none) = TS . eq cvul'(SKO, T ;; TS, SB) = ('_->_['true.NuITP-Bool,'_=_[freeze(T),applySub(unfreeze(T,SKO),SB)]]) ;; cvul'(SKO, TS, SB) . --- Constructor Variant Unification Failure Right (CVUFR) crl [cvufr] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_[GAMMA,'_=_[LHS,RHS]] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_[GAMMA,'_=_[LHS,RHS]] } | GS' { ID + ".1", 'CVUFR, SKO, HPS, getTerm(metaReduce(redModule(M, SKO),'_->_[GAMMA,'false.NuITP-Bool])) } if isSigma1?(addOps(M, SKO), '_=_[LHS,RHS]) /\ getCUnifiers(addOps(M, SKO), unfreeze(LHS, SKO), unfreeze(RHS, SKO)) == mt . crl [cvufr] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_[GAMMA, '_\/_[TL,'_=_[LHS,RHS],TL']] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_[GAMMA, '_\/_[TL,'_=_[LHS,RHS],TL']] } | GS' { ID + ".1", 'CVUFR, SKO, HPS, getTerm(metaReduce(redModule(M, SKO),'_->_[GAMMA,'_\/_[TL,'false.NuITP-Bool,TL']])) } if isSigma1?(addOps(M, SKO), '_=_[LHS,RHS]) /\ getCUnifiers(addOps(M, SKO), unfreeze(LHS, SKO), unfreeze(RHS, SKO)) == mt . --- Substitution Left (SUBL) crl [subl] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[V,T],TL'],LAMBDA] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[V,T],TL'],LAMBDA] } | GS' { ID + ".1", 'SUBL, SKO, HPS, getTerm(metaReduce(redModule(M, SKO), applySub('_->_[(TL,TL'),LAMBDA],(V <- T)))) } if sortLeq(M,leastSort(addOps(M, SKO), T), getType(V)) /\ not(V in getVars(T)) /\ not(isSigma1?(addOps(M, SKO), T)) /\ not(isSigma1?(addOps(M, SKO), (TL,TL'))) . crl [subl] : M | LOG | GS | { ID, RID, C ;; SKO, HPS, '_->_['_/\_[TL,'_=_[C,T],TL'],LAMBDA] } GS' => M | LOG | GS { ID, RID, C ;; SKO, HPS, '_->_['_/\_[TL,'_=_[C,T],TL'],LAMBDA] } | GS' { ID + ".1", 'SUBL, (C ;; SKO ;; freeze(getVars(T))), hsimp( M, (C ;; SKO ;; freeze(getVars(T))), (HPS ;; ('_->_['true.NuITP-Bool,'_=_[C,freeze(T)]])) ), getTerm(metaReduce( redModule(M, (C ;; SKO ;; freeze(getVars(T)))), applySub('_->_[(TL,TL'),LAMBDA],((unfreeze(C) <- T) ; skolemSub(getVars(T)))) )) } if sortLeq(addOps(M, C ;; SKO), leastSort(M,T), getType(C)) /\ not(C in getVars(T)) /\ not(isSigma1?(addOps(M, C ;; SKO), T)) /\ not(isSigma1?(addOps(M, C ;; SKO), (TL,TL'))) . --- Substitution Right (SUBR) crl [subr] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_[GAMMA,'_/\_[TL,'_=_[V,T],TL']] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_[GAMMA,'_/\_[TL,'_=_[V,T],TL']] } | GS' { ID + ".1", 'SUBR, SKO, HPS, getTerm(metaReduce(redModule(M, SKO), '_->_[GAMMA,'_=_[V,T]])) } { ID + ".2", 'SUBR, SKO, HPS, getTerm(metaReduce(redModule(M, SKO), applySub('_->_[GAMMA,(TL,TL')], (V <- T)))) } if (wrapAnd((TL,TL')) =/= 'true.NuITP-Bool) /\ sortLeq(addOps(M, SKO), leastSort(addOps(M, SKO), T), getType(V)) /\ not(V in T) . crl [subr] : M | LOG | GS | { ID, RID, C ;; SKO, HPS, '_->_[GAMMA,'_/\_[TL,'_=_[C,T],TL']] } GS' => M | LOG | GS { ID, RID, C ;; SKO, HPS, '_->_[GAMMA,'_/\_[TL,'_=_[C,T],TL']] } | GS' { ID + ".1", 'SUBR, SKO, HPS, getTerm(metaReduce(redModule(M, SKO), '_->_[GAMMA,'_=_[C,T]])) } { ID + ".2", 'SUBR, (C ;; (SKO ;; freeze(getVars(T)))), hsimp( M, (C ;; (SKO ;; freeze(getVars(T)))), (HPS ;; ('_=_[C,freeze(T)])) ), getTerm(metaReduce(redModule(M, (C ;; (SKO ;; freeze(getVars(T))))), applySub('_->_[GAMMA,(TL,TL')],((unfreeze(C) <- T) ; skolemSub(getVars(T)))))) } if (wrapAnd((TL,TL')) =/= 'true.NuITP-Bool) /\ sortLeq(addOps(M, C ;; SKO), leastSort(addOps(M, C ;; SKO), T), getType(C)) /\ not(C in T) . --- Narrowing Simplification (NS) crl [ns] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_['_=_[F[NTL],RHS],LAMBDA] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_['_=_[F[NTL],RHS],LAMBDA] } | GS' ns(M, euR(M), { ID, RID, SKO, HPS, '_->_['_=_[F[NTL],RHS],LAMBDA] }, F[NTL], skvars(F[NTL], SKO), RHS, '_->_[[],LAMBDA], 0) if isSigma1?(addOps(M, SKO), RHS) /\ not(sigma1Top?(addOps(M, SKO), F[NTL])) /\ isNarrowex(euR(addOps(M, SKO)), F[NTL]) . crl [ns] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_[GAMMA, '_=_[F[NTL],RHS]] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_[GAMMA, '_=_[F[NTL],RHS]] } | GS' ns(M, euR(M), { ID, RID, SKO, HPS, '_->_[GAMMA, '_=_[F[NTL],RHS]] }, F[NTL], skvars(F[NTL], SKO), RHS, '_->_[GAMMA, []], 0) if isSigma1?(addOps(M, SKO), RHS) /\ not(sigma1Top?(addOps(M, SKO), F[NTL])) /\ isNarrowex(euR(addOps(M, SKO)), F[NTL]) . crl [ns] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[F[NTL],RHS],TL'],LAMBDA] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[F[NTL],RHS],TL'],LAMBDA] } | GS' ns(M, euR(M), { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[F[NTL],RHS],TL'],LAMBDA] }, F[NTL], skvars(F[NTL], SKO), RHS, '_->_['_/\_[TL,[],TL'],LAMBDA], 0) if isSigma1?(addOps(M, SKO), RHS) /\ not(sigma1Top?(addOps(M, SKO), F[NTL])) /\ isNarrowex(euR(addOps(M, SKO)), F[NTL]) . crl [ns] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_[GAMMA, '_\/_[TL,'_=_[F[NTL],RHS],TL']] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_[GAMMA, '_\/_[TL,'_=_[F[NTL],RHS],TL']] } | GS' ns(M, euR(M), { ID, RID, SKO, HPS, '_->_[GAMMA, '_\/_[TL,'_=_[F[NTL],RHS],TL']] }, F[NTL], skvars(F[NTL], SKO), RHS, '_->_[GAMMA, '_\/_[TL,[],TL']], 0) if isSigma1?(addOps(M, SKO), RHS) /\ not(sigma1Top?(addOps(M, SKO), F[NTL])) /\ isNarrowex(euR(addOps(M, SKO)), F[NTL]) . op ns : Module Module Goal Term TermSet Term Context Nat -> GoalSet . ceq ns(M, MR, { ID, RID, SKO, HPS, '_->_[GAMMA,LAMBDA] }, TV, SKTV, TU, CO, N) = { ID + "." + string(N + 1,10), 'NS, (SKO ;; freeze(applySub(SKTV, SB3))), nsHPS( M, (SKO ;; freeze(applySub(SKTV, SB3))), HPS, freeze(SB3, freeze(applySub(SKTV, SB3))), SKTV, mt ), getTerm(metaReduce( --- TODO: Conditional Narrowing adding rule's condition to GAMMA redModule(M, (SKO ;; freeze(applySub(SKTV, SB3)))), applySub( replaceHole(CO, '_=_[safeVars(T, ID + "." + string(N + 1,10)),TU]), freeze(SB3, freeze(applySub(SKTV, SB3))) ) )) } ns(M, MR, { ID, RID, SKO, HPS, '_->_[GAMMA,LAMBDA] }, TV, SKTV, TU, CO, N + 1) if { T, TY, CO', F, SB1, (V <- T' ; SB2), F' } := metaNarrowingApply(addOps(MR, SKO), unfreeze(TV, SKO), empty, '#, none, N) /\ SB3 := saferVars(SB1, ID + "." + string(N + 1,10)) ; saferVars((V <- T' ; SB2), ID + "." + string(N + 1,10)) . eq ns(M, MR, { ID, RID, SKO, HPS, CLA }, TV, SKTV, TU, CO, N) = mt [ owise ] . op nsHPS : Module TermSet TermSet Substitution TermSet TermSet -> TermSet . eq nsHPS(M, SKO, HPS, SB, mt, mt) = HPS . eq nsHPS(M, SKO, HPS, SB, mt, NTS) = hsimp(M, SKO, HPS ;; NTS) . eq nsHPS(M, SKO, HPS, SB, T ;; NTS, NTS') = nsHPS(M, SKO, HPS, SB, NTS, NTS' ;; ('_->_['true.NuITP-Bool,'_=_[freeze(T), applySub(T, SB)]])) . --- Clause Subsumption (CS) crl [cs] : M | LOG | GS | { ID, RID, SKO, (HPS ;; ('_->_[HP,HP'])), '_->_[GAMMA,LAMBDA] } GS' => M | LOG | GS { ID, RID, SKO, (HPS ;; ('_->_[HP,HP'])), '_->_[GAMMA,LAMBDA] } | GS' { ID + ".1", 'CS, SKO, (HPS ;; ('_->_[HP,HP'])), getTerm(metaReduce(redModule(M, SKO), '_->_[GAMMA,LAMBDA'])) } if LAMBDA' := cs(addOps(M,SKO), disorient(HP), disorient(HP'), GAMMA, LAMBDA) . op cs : Module Term Term Term Term -> [Term] . ceq cs(M, HP, HP', GAMMA, LAMBDA) = applySub('NuITP-ESC:`[NuITP-Bool`],SB) if SB := metaMatch(M, '_->_['_/\_['NuITP-ES:`[NuITP-Bool`],HP],'_/\_['_\/_[HP','NuITP-ES':`[NuITP-Bool`]],'NuITP-ESC:`[NuITP-Bool`]]], '_->_[GAMMA,LAMBDA], nil, 0) . ceq cs(M, HP, HP', GAMMA, LAMBDA) = applySub('NuITP-ESC:`[NuITP-Bool`],SB) if SB := metaMatch(M, '_->_[HP,'_/\_['_\/_[HP','NuITP-ES':`[NuITP-Bool`]],'NuITP-ESC:`[NuITP-Bool`]]], '_->_[GAMMA,LAMBDA], nil, 0) . ceq cs(M, HP, HP', GAMMA, LAMBDA) = 'true.NuITP-Bool if SB := metaMatch(M, '_->_['_/\_['NuITP-ES:`[NuITP-Bool`],HP],'_\/_[HP','NuITP-ES':`[NuITP-Bool`]]], '_->_[GAMMA,LAMBDA], nil, 0) . ceq cs(M, HP, HP', GAMMA, LAMBDA) = 'true.NuITP-Bool if SB := metaMatch(M, '_->_[HP,'_\/_[HP','NuITP-ES':`[NuITP-Bool`]]], '_->_[GAMMA,LAMBDA], nil, 0) . ceq cs(M, HP, HP', GAMMA, LAMBDA) = 'true.NuITP-Bool if SB := metaMatch(M, '_->_['_/\_['NuITP-ES:`[NuITP-Bool`],HP],HP'], '_->_[GAMMA,LAMBDA], nil, 0) . ceq cs(M, HP, HP', GAMMA, LAMBDA) = 'true.NuITP-Bool if SB := metaMatch(M, '_->_[HP,HP'], '_->_[GAMMA,LAMBDA], nil, 0) . --- Inductive Congruence Closure (ICC) crl [icc] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_[GAMMA,LAMBDA] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_[GAMMA,LAMBDA] } | GS' icc(M, { ID, RID, SKO, HPS, '_->_[GAMMA,LAMBDA] }, SKO', GAMMA#!) if SKO' := freeze(getVars('_->_[GAMMA,LAMBDA])) /\ GAMMA# := wrapAndCC(cong-closure(addOps(M, SKO ;; SKO'), unwrapAndCC(freeze(GAMMA)) ;; hgeu(HPS))) /\ GAMMA#! := (getTerm(metaSearch(addRls(addOps(eqPreds(M), SKO ;; SKO'), heu++(HPS)), GAMMA#, 'RES:`[NuITP-Bool`], nil, '!, unbounded, 0))) . op icc : Module Goal TermSet TermSet -> GoalSet . eq icc(M, { ID, RID, SKO, HPS, '_->_[GAMMA,LAMBDA] }, SKO', 'false.NuITP-Bool) = { ID + ".1", 'ICC, SKO, HPS, 'true.NuITP-Bool } . eq icc(M, { ID, RID, SKO, HPS, '_->_[GAMMA,LAMBDA] }, SKO', GAMMA#) = if (icc'(M, SKO, SKO', heu++(HPS), LAMBDA, GAMMA#) == mt) then { ID + ".1", 'ICC, SKO, HPS, '_->_[GAMMA,LAMBDA] } else if iccAllTrue(icc'(M, SKO, SKO', heu++(HPS), LAMBDA, GAMMA#)) then { ID + ".1", 'ICC, SKO, HPS, 'true.NuITP-Bool } else iccIndex(ID, icc'(M, SKO, SKO', heu++(HPS), LAMBDA, GAMMA#), 1) fi fi [ owise ] . op icc' : Module TermSet TermSet TermSet Term TermSet -> GoalSet . eq icc'(M, SKO, SKO', HPS, LAMBDA, mt) = mt . eq icc'(M, SKO, SKO', HPS, LAMBDA, GAMMA#i ;; GAMMA#) = icc''(M, SKO, SKO', HPS, LAMBDA, GAMMA#i, 0) icc'(M, SKO, SKO', HPS, LAMBDA, GAMMA#) . op icc'' : Module TermSet TermSet TermSet Term Term Nat -> GoalSet . ceq icc''(M, SKO, SKO', HPS, LAMBDA, GAMMA#i, N) = { "", 'ICC, SKO, HPS, '_->_[disorient(unfreeze(GAMMA#i, SKO')),unfreeze(LAMBDAi, SKO')] } icc''(M, SKO, SKO', HPS, LAMBDA, GAMMA#i, N + 1) if LAMBDAi := getTerm(metaSearch(addRls(addOps(eqPreds(M), SKO ;; SKO'), cong-closure(addOps(M, SKO ;; SKO'), HPS ;; unwrapAndCC(GAMMA#i)) ;; GAMMA#i), freeze(LAMBDA), 'RES:`[NuITP-Bool`], nil, '!, unbounded, N)) . eq icc''(M, SKO, SKO', HPS, LAMBDA, GAMMA#i, N) = mt [ owise ] . op iccAllTrue : GoalSet -> Bool . eq iccAllTrue(mt) = true . eq iccAllTrue({ ID, 'ICC, SKO, HPS, '_->_[GAMMA,'true.NuITP-Bool] } GS) = iccAllTrue(GS) . eq iccAllTrue(GS) = false [ owise ] . op iccIndex : String GoalSet Nat -> GoalSet . eq iccIndex(ID, mt, N) = mt . eq iccIndex(ID, { "", RID, SKO, HPS, CLA } GS, N) = { ID + "." + string(N,10), RID, SKO, HPS, CLA } iccIndex(ID, GS, N + 1) . --- Variant Satisfiability (VARSAT) crl [varsat] : M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS' => M | LOG | GS { ID, RID, SKO, HPS, CLA } | GS' { ID + ".1", 'VARSAT, SKO, HPS, 'true.NuITP-Bool } if isSigma1?(addOps(M, SKO), CLA) /\ not(sat?(sigma1(addOps(M, SKO)), toDNF(sigma1(addOps(M, SKO)), 'not_[unfreeze(CLA, SKO)]))) . op sat? : Module Term -> Bool . eq sat?(M, 'not_[T]) = not(sat?(M, T)) . eq sat?(M, '_\/_[T,T']) = sat?(M, T) or-else sat?(M, T') . eq sat?(M, '_\/_[T,T',NTL]) = sat?(M, T) or-else sat?(M, '_\/_[T',NTL]) . eq sat?(M, '_/\_[NTL]) = sat?(M, NTL, empty, empty, nil) . eq sat?(M, '_=_[TU,TV]) = (metaVariantUnify(auxModule(M), '_=?=_[TU,TV] =? 'NuITP-tt.NuITP-Bool, empty, '#, filter delay, 0) :: UnificationPair) . op sat? : Module TermList TermList TermList TypeList -> Bool . eq sat?(M, empty, TUL, TVL, TYL) = (metaVariantUnify(auxModule(addOps(M, (op 'auxWrapper : TYL -> 'NuITP-Bool [ ctor ] .))), '_=?=_['auxWrapper[TUL],'auxWrapper[TVL]] =? 'NuITP-tt.NuITP-Bool, empty, '#, filter delay, 0) :: UnificationPair) . eq sat?(M, '_=_[TU,TV], TUL, TVL, TYL) = sat?(M, empty, (TUL,TU), (TVL,TV), (TYL getKind(M, leastSort(M, TU)))) . eq sat?(M, ('_=_[TU,TV],NTL), TUL, TVL, TYL) = sat?(M, NTL, (TUL,TU), (TVL,TV), (TYL getKind(M, leastSort(M, TU)))) . --- Equality (EQ) crl [eq] : M | LOG | GS | { ID, RID, SKO, HPS ;; HP, CLA } GS' => M | LOG | GS { ID, RID, SKO, HPS ;; HP, CLA } | GS' { ID + ".1", 'EQ, SKO, HPS ;; HP, T } if metaMatch(addOps(M, SKO ;; freeze(getVars(HP)) ;; freeze(getVars(ARG1:Term))), freeze(HP), freeze(disorient(wrapCond(ARG1:Term))), nil, 0) == none /\ { T, TY, SB, CO } := metaXapply(addEqs(addRls(addOps(M, SKO), toRls(wrapCond(ARG1:Term), ARG2:Substitution)), heu+(HPS)), CLA, 'NuITP-EQRL, none, 0, unbounded, 0) [nonexec] . crl [eq!] : M | LOG | GS | { ID, RID, SKO, HPS ;; HP, CLA } GS' => M | LOG | GS { ID, RID, SKO, HPS ;; HP, CLA } | GS' apply!(M, { ID + ".1", 'EQ, SKO, HPS ;; HP, T }) if metaMatch(addOps(M, SKO ;; freeze(getVars(HP)) ;; freeze(getVars(ARG1:Term))), freeze(HP), freeze(disorient(wrapCond(ARG1:Term))), nil, 0) == none /\ { T, TY, SB, CO } := metaXapply(addEqs(addRls(addOps(M, SKO), toRls(wrapCond(ARG1:Term), ARG2:Substitution)), heu+(HPS)), CLA, 'NuITP-EQRL, none, 0, unbounded, 0) [nonexec] . endm --- Standard Inductive Rules mod NuITP-INDUCTION-RULES is pr NuITP-SIMPLIFICATION-RULES . vars M MR : Module . var C : Constant . var G : Goal . vars GS GS' : GoalSet . vars SKO HPS GEN : TermSet . var V : Variable . vars F F' RID : Qid . vars TY TY' : Type . var TYL : TypeList . var ATS : AttrSet . var OPDS : OpDeclSet . vars N CNT : Nat . vars T T' TU TV TW CLA GAMMA LAMBDA DELTA LHS RHS DELTAK DIS : Term . vars NTL NTL' : NeTermList . vars TL TL' : TermList . vars TS TS' CLAS DELTAS SSCS : TermSet . vars ID PA STR : String . vars SB SB1 SB2 SB3 : Substitution . vars CO CO' : Context . var NTS : NeTermSet . var LOG : StringList . --- Generator Set Induction (GSI) crl [gsi] : M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS' => M | LOG | GS { ID, RID, SKO, HPS, CLA } | GS' gsi(M, { ID, RID, SKO, HPS, CLA }, ARG1:Variable, ARG2:TermSet) if ARG1:Variable in CLA /\ getVars(ARG2:TermSet) notIn getVars(CLA) [nonexec] . crl [gsi!] : M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS' => M | LOG | GS { ID, RID, SKO, HPS, CLA } | GS' apply!(M, gsi(M, { ID, RID, SKO, HPS, CLA }, ARG1:Variable, ARG2:TermSet)) if ARG1:Variable in CLA /\ getVars(ARG2:TermSet) notIn getVars(CLA) [nonexec] . op gsi : Module Goal Variable TermSet -> GoalSet . eq gsi(M, { ID, RID, SKO, HPS, CLA }, V, GEN) = gsi(M, { ID, RID, SKO, HPS, CLA }, V, GEN, 1) . op gsi : Module Goal Variable TermSet Nat -> GoalSet . eq gsi(M, { ID, RID, SKO, HPS, CLA }, V, mt, N) = mt . eq gsi(M, { ID, RID, SKO, HPS, CLA }, V, (T ;; TS), N) = { ID + "." + string(N,10), 'GSI, (SKO ;; freeze(getVars(T))), gsiHPS( M, (SKO ;; freeze(getVars(T))), HPS, split(CLA), V, getSubTerms(addOps(M, (SKO ;; freeze(getVars(T)))), V, freeze(T), getType(V), 0), mt ), getTerm(metaReduce(redModule(M, (SKO ;; freeze(getVars(T)))), applySub(CLA, V <- freeze(T)))) } gsi(M, { ID, RID, SKO, HPS, CLA }, V, TS, N + 1) . op gsiHPS : Module TermSet TermSet TermSet Variable TermSet TermSet -> TermSet . eq gsiHPS(M, SKO, HPS, CLAS, V, mt, TS) = hsimp(M, SKO, HPS ;; TS) . --- CHECK e=xu(M, SKO) previously eq gsiHPS(M, SKO, HPS, CLAS, V, (T ;; TS), TS') = gsiHPS(M, SKO, HPS, CLAS, V, TS, (TS' ;; reduceSet(e=xu(M, SKO), applySub(CLAS, V <- T)))) . op getSubTerms : Module Variable Term Type Nat -> TermSet . eq getSubTerms(M, V, T, TY, N) = mt [ owise ] . ceq getSubTerms(M, V, T, TY, N) = if (CO == []) then mt else applySub(V,SB) fi ;; getSubTerms(M,V,T,TY,N + 1) if { SB , CO } := metaXmatch(M, V, T, nil, 0, unbounded, N) . --- Narrowing Induction (NI) crl [ni] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] } | GS' niGamma(M, euR(M), { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] }, ARG1:Term, '_->_[unfreeze(CO, freeze(getVars(GAMMA))),DELTA], 0) if { none , CO } := metaXmatch(addOps(M, SKO ;; freeze(getVars(ARG1:Term ;; GAMMA))), freeze(ARG1:Term), freeze(GAMMA), nil, 0, unbounded, 0) /\ (skvars(ARG1:Term, SKO) == mt) /\ isNarrowex(euR(M), ARG1:Term) [nonexec] . crl [ni] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] } | GS' niDelta(M, euR(M), { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] }, replaceHole(getDeltaK(unfreeze(CO, freeze(getVars(DELTA)))), ARG1:Term), ARG1:Term, '_->_[GAMMA,getDeltaK(unfreeze(CO, freeze(getVars(DELTA))))], 0) if { none , CO } := metaXmatch(addOps(M, SKO ;; freeze(getVars(ARG1:Term ;; DELTA))), freeze(ARG1:Term), freeze(DELTA), nil, 0, unbounded, 0) /\ (skvars(ARG1:Term, SKO) == mt) /\ isNarrowex(euR(M), ARG1:Term) [nonexec] . crl [ni!] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] } | GS' apply!(M, niGamma(M, euR(M), { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] }, ARG1:Term, '_->_[unfreeze(CO, freeze(getVars(GAMMA))),DELTA], 0)) if { none , CO } := metaXmatch(addOps(M, SKO ;; freeze(getVars(ARG1:Term ;; GAMMA))), freeze(ARG1:Term), freeze(GAMMA), nil, 0, unbounded, 0) /\ (skvars(ARG1:Term, SKO) == mt) /\ isNarrowex(euR(M), ARG1:Term) [nonexec] . crl [ni!] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] } | GS' apply!(M, niDelta(M, euR(M), { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] }, replaceHole(getDeltaK(unfreeze(CO, freeze(getVars(DELTA)))), ARG1:Term), ARG1:Term, '_->_[GAMMA,getDeltaK(unfreeze(CO, freeze(getVars(DELTA))))], 0)) if { none , CO } := metaXmatch(addOps(M, SKO ;; freeze(getVars(ARG1:Term ;; DELTA))), freeze(ARG1:Term), freeze(DELTA), nil, 0, unbounded, 0) /\ (skvars(ARG1:Term, SKO) == mt) /\ isNarrowex(euR(M), ARG1:Term) [nonexec] . op niGamma : Module Module Goal Term Context Nat -> GoalSet . ceq niGamma(M, MR, { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] }, TV, '_->_[CO,DELTA], N) = niGoal(M, ID + "." + string(N + 1,10), SKO, HPS, '_->_[CO,DELTA], TV, T, SB3, reduceSet( addOps(eqPreds(M), (SKO ;; freeze(getRanVars(SB3)))), split(niHPS(M, (SKO ;; freeze(getRanVars(SB3))), '_->_[GAMMA,DELTA], TV, applySub(ssc(addOps(MR, (SKO ;; freeze(getRanVars(SB3)))), getRule(MR, F)), SB3))) ) ) niGamma(M, MR, { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] }, TV, '_->_[CO,DELTA], N + 1) if { T, TY, CO', F, SB1, SB2, F' } := metaNarrowingApply(addOps(MR, SKO), TV, empty, '#, none, N) /\ SB3 := saferVars(SB1, ID + "." + string(N + 1,10)) ; saferVars(SB2, ID + "." + string(N + 1,10)) . eq niGamma(M, MR, { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] }, TV, '_->_[CO,DELTA], N) = mt [ owise ] . op niDelta : Module Module Goal Term Term Context Nat -> GoalSet . ceq niDelta(M, MR, { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] }, DELTAK, TV, CO, N) = niGoal(M, ID + "." + string(N + 1,10), SKO, HPS, CO, TV, T, SB3, reduceSet( addOps(eqPreds(M), (SKO ;; freeze(getRanVars(SB3)))), niHPS(M, (SKO ;; freeze(getRanVars(SB3))), '_->_[GAMMA,DELTAK], TV, applySub(ssc(addOps(MR, (SKO ;; freeze(getRanVars(SB3)))), getRule(MR, F)), SB3)) ) ) niDelta(M, MR, { ID, RID, SKO, HPS, '_->_[GAMMA, DELTA] }, DELTAK, TV, CO, N + 1) if { T, TY, CO', F, SB1, SB2, F' } := metaNarrowingApply(addOps(MR, SKO), TV, empty, '#, none, N) /\ SB3 := safeVars(SB1, ID + "." + string(N + 1,10)) ; safeVars(SB2, ID + "." + string(N + 1,10)) . eq niDelta(M, MR, { ID, RID, SKO, HPS, '_->_[GAMMA,DELTA] }, DELTAK, TV, CO, N) = mt [ owise ] . op niGoal : Module String TermSet TermSet Context Term Term Substitution TermSet -> GoalSet . eq niGoal(M, ID, SKO, HPS, CO, TV, T, SB, mt) = { ID, 'NI, SKO, HPS, getTerm( metaReduce( redModule(M, SKO), applySub(replaceHole(CO, safeVars(T, ID)), SB) ) ) } . eq niGoal(M, ID, SKO, HPS, CO, TV, T, SB, NTS) = { ID, 'NI, (SKO ;; freeze(getRanVars(SB))), hsimp( M, (SKO ;; freeze(getRanVars(SB))), HPS ;; freeze(NTS, getRanVars(SB)) ), getTerm( metaReduce( redModule(M, (SKO ;; freeze(getRanVars(SB)))), freeze(applySub(replaceHole(CO, safeVars(T, ID)), SB), getVars(applySub(TV, SB))) ) ) } . op niHPS : Module TermSet Term Term TermSet -> TermSet . eq niHPS(M, SKO, CLA, TV, mt) = mt . eq niHPS(M, SKO, CLA, TV, T) = if metaMatch(M, TV, T, nil, 0) :: Substitution then split(applySub(CLA, metaMatch(M, TV, T, nil, 0))) else mt fi . eq niHPS(M, SKO, CLA, TV, T ;; NTS) = niHPS(M, SKO, CLA, TV, T) ;; niHPS(M, SKO, CLA, TV, NTS) . op getDeltaK : Context -> Term . eq getDeltaK('_/\_[TL,CO,TL']) = CO . eq getDeltaK(CO) = CO [ owise ] . --- Lemma Enrichment (LE) rl [le] : M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS' => M | LOG | GS { ID, RID, SKO, HPS, CLA } | GS' { ID + ".1", 'LE, freeze(skvars(ARG1:Term, SKO)), mt, ARG1:Term } { ID + ".2", 'LE, SKO, hsimp(M, SKO, HPS ;; split(ARG1:Term)), CLA } [nonexec] . rl [le!] : M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS' => M | LOG | GS { ID, RID, SKO, HPS, CLA } | GS' apply!(M, { ID + ".1", 'LE, freeze(skvars(ARG1:Term, SKO)), mt, ARG1:Term } { ID + ".2", 'LE, SKO, hsimp(M, SKO, HPS ;; split(ARG1:Term)), CLA }) [nonexec] . --- Split (SP) crl [sp] : M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS' => M | LOG | GS { ID, RID, SKO, HPS, CLA } | GS' { ID + ".1", 'SP, freeze(skvars(ARG1:Term, SKO)), mt, getTerm(metaReduce(redModule(M, SKO), '_->_['true.NuITP-Bool,ARG1:Term]))} sp(M, { ID, RID, SKO, HPS, CLA }, ARG1:Term, ARG2:Substitution, 2) if getVars(applySub(ARG1:Term, ARG2:Substitution)) in getVars(CLA) [nonexec] . crl [sp!] : M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS' => M | LOG | GS { ID, RID, SKO, HPS, CLA } | GS' apply!(M, { ID + ".1", 'SP, freeze(skvars(ARG1:Term, SKO)), mt, getTerm(metaReduce(redModule(M, SKO), '_->_['true.NuITP-Bool,ARG1:Term]))} sp(M, { ID, RID, SKO, HPS, CLA }, ARG1:Term, ARG2:Substitution, 2)) if getVars(applySub(ARG1:Term, ARG2:Substitution)) in getVars(CLA) [nonexec] . op sp : Module Goal TermList Substitution Nat -> GoalSet . eq sp(M, { ID, RID, SKO, HPS, CLA }, '_\/_[T,NTL], SB, N) = { ID + "." + string(N,10), 'SP, SKO, HPS, addGamma(addOps(M,SKO), CLA, applySub(T,SB)) } sp(M, { ID, RID, SKO, HPS, CLA }, NTL, SB, N + 1) . eq sp(M, { ID, RID, SKO, HPS, CLA }, T, SB, N) = { ID + "." + string(N,10), 'SP, SKO, HPS, addGamma(addOps(M,SKO), CLA, applySub(T,SB)) } [ owise ] . eq sp(M, { ID, RID, SKO, HPS, CLA }, (T, NTL), SB, N) = { ID + "." + string(N,10), 'SP, SKO, HPS, addGamma(addOps(M,SKO), CLA, applySub(T,SB)) } sp(M, { ID, RID, SKO, HPS, CLA }, NTL, SB, N + 1) [ owise ] . op addGamma : Module Term Term -> Term . eq addGamma(M, '_->_['true.NuITP-Bool,LAMBDA], T) = '_->_[T,LAMBDA] . eq addGamma(M, '_->_[GAMMA,LAMBDA], T) = getTerm(metaNormalize(M,'_->_['_/\_[GAMMA,T],LAMBDA])) [ owise ] . --- Case (CAS) crl [cas] : M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS' => M | LOG | GS { ID, RID, SKO, HPS, CLA } | GS' cas(M, { ID, RID, SKO, HPS, CLA }, ARG1:Variable, ARG2:TermSet, 1) if ARG1:Variable in CLA /\ getVars(ARG2:TermSet) notIn getVars(CLA) [nonexec] . crl [cas!] : M | LOG | GS | { ID, RID, SKO, HPS, CLA } GS' => M | LOG | GS { ID, RID, SKO, HPS, CLA } | GS' apply!(M, cas(M, { ID, RID, SKO, HPS, CLA }, ARG1:Variable, ARG2:TermSet, 1)) if ARG1:Variable in CLA /\ getVars(ARG2:TermSet) notIn getVars(CLA) [nonexec] . crl [cas] : M | LOG | GS | { ID, RID, ARG1:Constant ;; SKO, HPS, CLA } GS' => M | LOG | GS { ID, RID, ARG1:Constant ;; SKO, HPS, CLA } | GS' cas(M, { ID, RID, ARG1:Constant ;; SKO, HPS, CLA }, ARG1:Constant, ARG2:TermSet, 1) if ARG1:Constant in CLA /\ getVars(ARG2:TermSet) notIn getVars(CLA) [nonexec] . crl [cas!] : M | LOG | GS | { ID, RID, ARG1:Constant ;; SKO, HPS, CLA } GS' => M | LOG | GS { ID, RID, ARG1:Constant ;; SKO, HPS, CLA } | GS' apply!(M, cas(M, { ID, RID, ARG1:Constant ;; SKO, HPS, CLA }, ARG1:Constant, ARG2:TermSet, 1)) if ARG1:Constant in CLA /\ getVars(ARG2:TermSet) notIn getVars(CLA) [nonexec] . op cas : Module Goal Term TermSet Nat -> GoalSet . eq cas(M, { ID, RID, SKO, HPS, CLA }, V, mt, N) = mt . eq cas(M, { ID, RID, SKO, HPS, CLA }, V, (T ;; TS), N) = { ID + "." + string(N,10), 'CAS, SKO, HPS, getTerm(metaReduce(redModule(M, SKO), applySub(CLA, V <- T))) } cas(M, { ID, RID, SKO, HPS, CLA }, V, TS, N + 1) . eq cas(M, { ID, RID, SKO, HPS, CLA }, C, mt, N) = mt . eq cas(M, { ID, RID, SKO, HPS, CLA }, C, (T ;; TS), N) = { ID + "." + string(N,10), 'CAS, (SKO ;; freeze(getVars(T))), hsimp( M, SKO ;; freeze(getVars(T)), HPS ;; ('_->_['true.NuITP-Bool,'_=_[C,freeze(T)]]) ), getTerm(metaReduce(redModule(M, (SKO ;; freeze(getVars(T)))), freeze(applySub(unfreeze(CLA,C), unfreeze(C) <- freeze(T)),C))) } cas(M, { ID, RID, SKO, HPS, CLA }, C, TS, N + 1) . --- Variable Abstraction (VA) crl [va] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_['_=_[TU,TV],LAMBDA] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_['_=_[TU,TV],LAMBDA] } | GS' va(M, { ID, RID, SKO, HPS, '_->_['_=_[TU,TV],LAMBDA] }, TU, TV) if metaMatch(addOps(M, SKO ;; freeze(getVars(ARG1:Term) ;; getVars(TV))), freeze(ARG1:Term), freeze(TV), nil, 0) :: Substitution /\ isSigma1?(addOps(M,SKO), TU) /\ not(isSigma1?(addOps(M,SKO), TV)) [nonexec] . crl [va] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[TU,TV],TL'],LAMBDA] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[TU,TV],TL'],LAMBDA] } | GS' va(M, { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[TU,TV],TL'],LAMBDA] }, TU, TV) if metaMatch(addOps(M, SKO ;; freeze(getVars(ARG1:Term) ;; getVars(TV))), freeze(ARG1:Term), freeze(TV), nil, 0) :: Substitution /\ isSigma1?(addOps(M,SKO), TU) /\ not(isSigma1?(addOps(M,SKO), TV)) [nonexec] . crl [va!] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_['_=_[TU,TV],LAMBDA] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_['_=_[TU,TV],LAMBDA] } | GS' apply!(M, va(M, { ID, RID, SKO, HPS, '_->_['_=_[TU,TV],LAMBDA] }, TU, TV)) if metaMatch(addOps(M, SKO ;; freeze(getVars(ARG1:Term) ;; getVars(TV))), freeze(ARG1:Term), freeze(TV), nil, 0) :: Substitution /\ isSigma1?(addOps(M,SKO), TU) /\ not(isSigma1?(addOps(M,SKO), TV)) [nonexec] . crl [va!] : M | LOG | GS | { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[TU,TV],TL'],LAMBDA] } GS' => M | LOG | GS { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[TU,TV],TL'],LAMBDA] } | GS' apply!(M, va(M, { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[TU,TV],TL'],LAMBDA] }, TU, TV)) if metaMatch(addOps(M, SKO ;; freeze(getVars(ARG1:Term) ;; getVars(TV))), freeze(ARG1:Term), freeze(TV), nil, 0) :: Substitution /\ isSigma1?(addOps(M,SKO), TU) /\ not(isSigma1?(addOps(M,SKO), TV)) [nonexec] . op va : Module Goal Term Term -> Goal . eq va(M, { ID, RID, SKO, HPS, '_->_['_=_[TU,TV],LAMBDA] }, TU, TV) = { ID + ".1", 'VA, SKO, HPS, getTerm( metaReduce( redModule(M, SKO), '_->_[ wrapAnd( ('_=_[TU,replaceMaxNotSigma1(TV, toSub(addOps(M,SKO), ID + ".1#", getMaxNotSigma1(addOps(M,SKO), TV), 1))], va(toSub(addOps(M,SKO), ID + ".1#", getMaxNotSigma1(addOps(M,SKO), TV), 1), empty)) ), LAMBDA ] ) ) } . op va : Module Goal Term Term -> Goal . eq va(M, { ID, RID, SKO, HPS, '_->_['_/\_[TL,'_=_[TU,TV],TL'],LAMBDA] }, TU, TV) = { ID + ".1", 'VA, SKO, HPS, getTerm( metaReduce( redModule(M, SKO), '_->_[ wrapAnd((TL, '_=_[TU,replaceMaxNotSigma1(TV, toSub(addOps(M,SKO), ID + ".1#", getMaxNotSigma1(addOps(M,SKO), TV), 1))], va(toSub(addOps(M,SKO), ID + ".1#", getMaxNotSigma1(addOps(M,SKO), TV), 1), empty), TL')), LAMBDA ] ) ) } . op va : Substitution TermList -> TermList . eq va(none, TL) = TL . eq va((V <- T ; SB), TL) = va(SB, (TL, '_=_[V, T])) . endm fmod NuITP-STRING is pr NuITP-STATE . pr NuITP-HSIMP . pr LEXICAL . vars G GF GP GU : Goal . vars GS FRO PRO UNP NEW : GoalSet . vars ID ID' PA : String . vars SKO SKO' HPS HPS' : TermSet . var NTS : NeTermSet . var TL : TermList . vars CLA CLA' GAMMA LAMBDA T T' LHS RHS : Term . var M : Module . var PDL : ParameterDeclList . var H : Header . var IL : ImportList . var SS : SortSet . var SSDS : SubsortDeclSet . var OPDS : OpDeclSet . var MAS : MembAxSet . var EQS : EquationSet . var RLS : RuleSet . var STD : StratDecl . var STDS : StratDeclSet . var STDF : StratDefinition . var STDFS : StratDefSet . vars F F' F'' Q Q' RID RID' : Qid . vars FL QL QL' QL'' PMODS PMODS' : QidList . var TYL : TypeList . var TY : Type . vars ME ME' : ModuleExpression . var PL : ParameterList . var PD : ParameterDecl . vars S S' : Sort . var SSD : SubsortDecl . var RS : RenamingSet . var A : Attr . var ATS : AttrSet . var R : Renaming . var NeNL : NeNatList . var NeHL : NeHookList . var HK : Hook . var HKL : HookList . var NL : NatList . var N : Nat . var STR : String . vars COND COND' : Condition . var OPD : OpDecl . var MA : MembAx . var EQ : Equation . var RL : Rule . var CST : CallStrategy . vars STA STA' STA'' : Strategy . var RAP : RuleApplication . vars UPS UPS' : UsingPairSet . vars STL STL' : StrategyList . var SB : Substitution . var V : Variable . op getIDs : GoalSet -> String . eq getIDs(mt) = "" . eq getIDs({ ID, RID, SKO, HPS, CLA }) = ID . eq getIDs({ ID, RID, SKO, HPS, CLA } { ID', RID', SKO', HPS', CLA' }) = ID + " and " + ID' [ owise ] . eq getIDs({ ID, RID, SKO, HPS, CLA } GS) = ID + ", " + getIDs(GS) [ owise ] . op toString : Module Term -> String . eq toString(M,T) = printTokens(metaPrettyPrint(M, none, T, mixfix)) . op toStringApply : Module GoalSet GoalSet -> String . eq toStringApply(M, FRO, NEW) = toStringApply'(M, FRO, getProved(NEW), removeProved(NEW)) . op toStringApply' : Module GoalSet GoalSet GoalSet -> String . eq toStringApply'(M, mt, mt, mt) = "" . eq toStringApply'(M, FRO, mt, GU UNP) = toString(M, GU UNP) . eq toStringApply'(M, mt, GP, mt) = " " + GREEN + "Goal " + getIDs(GP) + " has been proved.\n\n qed\n\n" + BW . eq toStringApply'(M, mt, GP PRO, mt) = " " + GREEN + "Goals " + getIDs(GP PRO) + " have been proved.\n\n qed\n\n" + BW [ owise ] . eq toStringApply'(M, FRO, GP, GU UNP) = " " + GREEN + "Goal " + getIDs(GP) + " has been proved.\n\n" + BW + toString(M, GU UNP) . eq toStringApply'(M, FRO, GP PRO, GU UNP) = " " + GREEN + "Goals " + getIDs(GP PRO) + " have been proved.\n\n" + BW + toString(M, GU UNP) [ owise ] . eq toStringApply'(M, GF FRO, GP, mt) = " " + GREEN + "Goal " + getIDs(GP) + " has been proved.\n\n " + RED + "Unproved goals:\n\n" + BW + toString(M, GF FRO) [ owise ] . eq toStringApply'(M, GF FRO, GP PRO, mt) = " " + GREEN + "Goals " + getIDs(GP PRO) + " have been proved.\n\n " + RED + "Unproved goals:\n\n" + BW + toString(M, GF FRO) [ owise ] . op toString : Module GoalSet -> String . eq toString(M, (mt).GoalSet) = "" . eq toString(M, { ID, RID, SKO, HPS, CLA}) = WHITE + " Goal Id: " + BW + ID + "\n" + WHITE + " Skolem Ops: " + BW + if (SKO == mt) then "\n None" else toStringSKO(addOps(M,SKO),SKO) fi + "\n" + WHITE + " Executable Hypotheses: " + BW + if (heu+(HPS) == mt) then "\n None" else toStringHPS(addOps(M,SKO),heu+(HPS)) fi + "\n" + WHITE + " Non-Executable Hypotheses: " + BW + if (hne(HPS) == mt) then "\n None" else toStringHPS(addOps(M,SKO),hne(HPS)) fi + "\n" + WHITE + " Goal: " + BW + "\n " + toStringCLA(addOps(M,SKO),CLA) + "\n\n" . eq toString(M, G GS) = toString(M, G) + toString(M, GS) [ owise ] . op toStringTeX : Module GoalSet -> String . eq toStringTeX(M, (mt).GoalSet) = "" . eq toStringTeX(M, { ID, RID, SKO, HPS, CLA}) = "\n" + "Goal Id: " + ID + "\n" + "Skolem Ops: " + if (SKO == mt) then "\n None" else toStringSKOTeX(addOps(M,SKO),SKO) fi + "\n" + "Executable Hypotheses: " + if (heu+(HPS) == mt) then "\n None" else toStringHPSTeX(addOps(M,SKO),heu+(HPS)) fi + "\n" + "Non-Executable Hypotheses: " + if (hne(HPS) == mt) then "\n None" else toStringHPSTeX(addOps(M,SKO),hne(HPS)) fi + "\n" + "Goal: \n " + toStringCLATeX(addOps(M,SKO),CLA) + "\n" . eq toStringTeX(M, G GS) = toStringTeX(M, G) + toStringTeX(M, GS) [ owise ] . op toStringCLA : Module Term -> String . eq toStringCLA(M,'true.NuITP-Bool) = GREEN + "true" + BW . eq toStringCLA(M,'false.NuITP-Bool) = RED + "false" + BW . eq toStringCLA(M,'_=_[LHS,RHS]) = toString(M,'_=_[LHS,RHS]) . eq toStringCLA(M,'_=>_[LHS,RHS]) = toString(M,'_=>_[LHS,RHS]) . eq toStringCLA(M,'_->_['true.NuITP-Bool,LAMBDA]) = toString(M,LAMBDA) . eq toStringCLA(M,'_->_[GAMMA,'true.NuITP-Bool]) = toString(M,GAMMA) + " -> true" . eq toStringCLA(M,'_->_[GAMMA,'false.NuITP-Bool]) = toString(M,GAMMA) + " -> false" . eq toStringCLA(M,'_->_[GAMMA,LAMBDA]) = toString(M,GAMMA) + " -> " + toString(M,LAMBDA) [ owise ] . op toStringCLATeX : Module Term -> String . eq toStringCLATeX(M,'true.NuITP-Bool) = "true" . eq toStringCLATeX(M,'false.NuITP-Bool) = "false" . eq toStringCLATeX(M,'_=_[LHS,RHS]) = toString(M,'_=_[LHS,RHS]) . eq toStringCLATeX(M,'_=>_[LHS,RHS]) = toString(M,'_=>_[LHS,RHS]) . eq toStringCLATeX(M,'_->_['true.NuITP-Bool,LAMBDA]) = toString(M,LAMBDA) . eq toStringCLATeX(M,'_->_[GAMMA,LAMBDA]) = toString(M,GAMMA) + " -> " + toString(M,LAMBDA) [ owise ] . op toStringSKO : Module TermSet -> String . eq toStringSKO(M,mt) = "" . eq toStringSKO(M,T) = "\n " + toString(M,T) + "." + string(getType(T)) . eq toStringSKO(M,T ;; NTS) = "\n " + toString(M,T) + "." + string(getType(T)) + toStringSKO(M,NTS) . op toStringSKOTeX : Module TermSet -> String . eq toStringSKOTeX(M,mt) = "" . eq toStringSKOTeX(M,T) = "\n " + toString(M,T) + "." + string(getType(T)) . eq toStringSKOTeX(M,T ;; NTS) = "\n " + toString(M,T) + "." + string(getType(T)) + toStringSKOTeX(M,NTS) . op toStringHPS : Module TermSet -> String . eq toStringHPS(M,mt) = "" . eq toStringHPS(M,T) = "\n " + toStringCLA(M,T) . eq toStringHPS(M,T ;; NTS) = "\n " + toStringCLA(M,T) + toStringHPS(M,NTS) . op toStringHPSTeX : Module TermSet -> String . eq toStringHPSTeX(M,mt) = "" . eq toStringHPSTeX(M,T) = "\n " + toStringCLATeX(M,T) . eq toStringHPSTeX(M,T ;; NTS) = "\n " + toStringCLATeX(M,T) + toStringHPSTeX(M,NTS) . op PRELUDE-MODS : -> QidList . eq PRELUDE-MODS = 'BOOL 'TRUTH-VALUE 'BOOL-OPS 'TRUTH 'EXT-BOOL 'NAT 'INT 'RAT 'FLOAT 'STRING 'CONVERSION 'RANDOM 'BOUND 'QID 'TRIV 'STRICT-WEAK-ORDER 'STRICT-TOTAL-ORDER 'TOTAL-PREORDER 'TOTAL-ORDER 'DEFAULT 'LIST 'WEAKLY-SORTABLE-LIST 'SORTABLE-LIST 'WEAKLY-SORTABLE-LIST' 'SORTABLE-LIST' 'SET 'LIST-AND-SET 'SORTABLE-LIST-AND-SET 'SORTABLE-LIST-AND-SET' 'LIST* 'SET* 'MAP 'ARRAY 'NAT-LIST 'QID-LIST 'QID-SET 'META-TERM 'META-CONDITION 'META-STRATEGY 'META-MODULE 'META-VIEW 'META-LEVEL 'LEXICAL 'COUNTER 'LOOP-MODE 'CONFIGURATION . op toString : Module -> String . eq toString(M) = toStringAllMods(getAllMods(M)) . op toStringAllMods : QidList -> String . eq toStringAllMods(nil) = "" . eq toStringAllMods(Q) = toString'(upModule(Q, false)) . eq toStringAllMods(Q Q' QL) = toString'(upModule(Q, false)) + "\n\n" + toStringAllMods(Q' QL) [ owise ] . op cleanImports : QidList QidList -> QidList . eq cleanImports(QL Q QL' Q QL'', PMODS) = cleanImports(QL Q QL' QL'', PMODS) . ceq cleanImports(QL Q QL', PMODS Q PMODS') = cleanImports(QL QL', PMODS Q PMODS') if QL' =/= nil . eq cleanImports(QL, PMODS) = QL [ owise ] . op getAllMods : Module -> QidList . eq getAllMods(M) = cleanImports(getAllMods(getImports(M)) getName(M), PRELUDE-MODS) . op getAllMods : ImportList -> QidList . eq getAllMods((nil).ImportList) = nil . eq getAllMods(extending ME .) = getAllMods(ME) . eq getAllMods(including ME .) = getAllMods(ME) . eq getAllMods(protecting ME .) = getAllMods(ME) . eq getAllMods(extending ME . IL) = getAllMods(ME) getAllMods(IL) [ owise ] . eq getAllMods(including ME . IL) = getAllMods(ME) getAllMods(IL) [ owise ] . eq getAllMods(protecting ME . IL) = getAllMods(ME) getAllMods(IL) [ owise ] . op getAllMods : ModuleExpression -> QidList . eq getAllMods(Q) = getAllMods(upModule(Q, false)) Q . eq getAllMods(Q{Q'}) = getAllMods(upModule(Q, false)) getAllMods(upModule(Q', false)) Q Q' . eq getAllMods(Q{Q'} + ME) = getAllMods(upModule(Q, false)) getAllMods(upModule(Q', false)) Q Q' getAllMods(ME) . eq getAllMods(Q + ME) = getAllMods(upModule(Q, false)) Q getAllMods(ME) . op toString' : Module -> String . eq toString'(fmod H is IL sorts SS . SSDS OPDS MAS EQS endfm) = "fmod " + toString((fmod H is IL sorts SS . SSDS OPDS MAS EQS endfm), H) + " is\n" + toString(IL) + toStringSS(SS) + toString(SSDS) + toString((fmod H is IL sorts SS . SSDS OPDS MAS EQS endfm), OPDS) + toString((fmod H is IL sorts SS . SSDS OPDS MAS EQS endfm), MAS) + toString((fmod H is IL sorts SS . SSDS OPDS MAS EQS endfm), EQS) + "endfm" . eq toString'(mod H is IL sorts SS . SSDS OPDS MAS EQS RLS endm) = "mod " + toString((mod H is IL sorts SS . SSDS OPDS MAS EQS RLS endm), H) + " is\n" + toString(IL) + toStringSS(SS) + toString(SSDS) + toString((mod H is IL sorts SS . SSDS OPDS MAS EQS RLS endm), OPDS) + toString((mod H is IL sorts SS . SSDS OPDS MAS EQS RLS endm), MAS) + toString((mod H is IL sorts SS . SSDS OPDS MAS EQS RLS endm), EQS) + toString((mod H is IL sorts SS . SSDS OPDS MAS EQS RLS endm), RLS) + "endm" . eq toString'(smod H is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm) = "smod " + toString((smod H is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm), H) + " is\n" + toString(IL) + toStringSS(SS) + toString(SSDS) + toString((smod H is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm), OPDS) + toString((smod H is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm), MAS) + toString((smod H is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm), EQS) + toString((smod H is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsm), RLS) + "endsm" . eq toString'(fth H is IL sorts SS . SSDS OPDS MAS EQS endfth) = "fth " + toString((fth H is IL sorts SS . SSDS OPDS MAS EQS endfth), H) + " is\n" + toString(IL) + toStringSS(SS) + toString(SSDS) + toString((fth H is IL sorts SS . SSDS OPDS MAS EQS endfth), OPDS) + toString((fth H is IL sorts SS . SSDS OPDS MAS EQS endfth), MAS) + toString((fth H is IL sorts SS . SSDS OPDS MAS EQS endfth), EQS) + "endfth" . eq toString'(th H is IL sorts SS . SSDS OPDS MAS EQS RLS endth) = "th " + toString((th H is IL sorts SS . SSDS OPDS MAS EQS RLS endth), H) + " is\n" + toString(IL) + toStringSS(SS) + toString(SSDS) + toString((th H is IL sorts SS . SSDS OPDS MAS EQS RLS endth), OPDS) + toString((th H is IL sorts SS . SSDS OPDS MAS EQS RLS endth), MAS) + toString((th H is IL sorts SS . SSDS OPDS MAS EQS RLS endth), EQS) + toString((th H is IL sorts SS . SSDS OPDS MAS EQS RLS endth), RLS) + "endth" . eq toString'(sth H is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth) = "sth " + toString((sth H is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth), H) + " is\n" + toString(IL) + toStringSS(SS) + toString(SSDS) + toString((sth H is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth), OPDS) + toString((sth H is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth), MAS) + toString((sth H is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth), EQS) + toString((sth H is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth), RLS) + toString((sth H is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth), STDS) + toString((sth H is IL sorts SS . SSDS OPDS MAS EQS RLS STDS STDFS endsth), STDFS) + "endsth" . eq toString'(M) = "Error printing module." [ owise ] . op toString : Module Header -> String . eq toString(M, Q) = string(Q) . eq toString(M, Q{PDL}) = string(Q) + "{ " + toString(M, PDL) + " }" . op toString : Module ParameterDeclList -> String . eq toString(M, (nil).ParameterDeclList) = "" . eq toString(M, S :: ME) = string(S) + " :: " + toString(ME) . eq toString(M, (PD, PDL)) = toString(M, PD) + ", " + toString(M, PDL) [ owise ] . op toString : ModuleExpression -> String . eq toString(Q{Q'}) = string(Q) + "{" + string(Q') + "}" . eq toString(Q{Q'} + ME) = string(Q) + "{" + string(Q') + "} + " + toString(ME) . eq toString(Q + ME) = string(Q) + " + " + toString(ME) [ owise ] . op toString : Module ModuleExpression -> String . eq toString(M, ME + ME') = toString(M, ME) + " + " + toString(M, ME') + "\n" . eq toString(M, ME *(RS)) = toString(M, ME) + " * (" + toString(M, RS) + ")\n" . eq toString(M, ME { PL }) = toString(M, ME) + " { " + toString(PL) + "}\n" . op toString : Module RenamingSet -> String . eq toString(M, sort F to F') = "sort " + string(F) + " to " + string(F') . eq toString(M, op F to F' [ ATS ]) = "op " + string(F) + " to " + string(F') + " [ " + toString(M, ATS) + " ]" . eq toString(M, op F : TYL -> TY to F' [ ATS ]) = "op " + string(F) + " : " + toString(TYL) + " -> " + string(TY) + " to " + string(F') + " [ " + toString(M, ATS) + " ]" . eq toString(M, label F to F') = "label " + string(F) + " to " + string(F') . eq toString(M, R, RS) = toString(M,R) + ", " + toString(M,RS) [ owise ] . op toString : ImportList -> String . eq toString((nil).ImportList) = "" . eq toString(extending ME . IL) = " ex " + toString(ME) + " .\n" + toString(IL) . eq toString(including ME . IL) = " inc " + toString(ME) + " .\n" + toString(IL) . eq toString(protecting ME . IL) = " pr " + toString(ME) + " .\n" + toString(IL) . op toStringSS : SortSet -> String . eq toStringSS((none).SortSet) = "" . eq toStringSS((S ; none)) = " sort " + string(S) + " .\n" . eq toStringSS(SS) = " sorts " + toStringSS'(SS) + " .\n" [ owise ] . op toStringSS' : SortSet -> String . eq toStringSS'(S) = string(S) . eq toStringSS'((S ; SS)) = string(S) + " " + toStringSS'(SS) [ owise ] . op toString : SubsortDeclSet -> String . eq toString((none).SubsortDeclSet) = "" . eq toString(subsort S < S' .) = " subsort " + string(S) + " < " + string(S') + " .\n" . eq toString(SSD SSDS) = toString(SSD) + toString(SSDS) [ owise ] . op toString : Module AttrSet -> String . eq toString(M, (none).AttrSet) = "" . eq toString(M, assoc) = "assoc" . eq toString(M, comm) = "comm" . eq toString(M, idem) = "idem" . eq toString(M, iter) = "iter" . eq toString(M, id(T)) = "id: " + toString(M,T) . eq toString(M, left-id(T)) = "left-id: " + toString(M,T) . eq toString(M, right-id(T)) = "right-id: " + toString(M,T) . eq toString(M, strat(NeNL)) = "strat (" + toString(NeNL) + ")" . eq toString(M, memo) = "memo" . eq toString(M, prec(N)) = "prec " + string(N,10) . eq toString(M, gather(FL)) = "gather (" + toString(FL) + ")" . eq toString(M, format(FL)) = "format (" + toString(FL) + ")" . eq toString(M, ctor) = "ctor" . eq toString(M, config) = "config" . eq toString(M, object) = "object" . eq toString(M, msg) = "msg" . eq toString(M, frozen(NeNL)) = "frozen (" + toString(NeNL) + ")" . eq toString(M, poly(NeNL)) = "poly (" + toString(NeNL) + ")" . eq toString(M, special(NeHL)) = "special (" + toString(M, NeHL) + ")" . eq toString(M, label(F)) = "label " + string(F) . eq toString(M, metadata(STR)) = "metadata \"" + STR + "\"" . eq toString(M, owise) = "owise" . eq toString(M, nonexec) = "nonexec" . eq toString(M, variant) = "variant" . eq toString(M, narrowing) = "narrowing" . eq toString(M, print(FL)) = "print" . eq toString(M, A ATS) = toString(M, A) + " " + toString(M, ATS) [ owise ] . op toString : NatList -> String . eq toString(N nil) = string(N,10) . eq toString(N NL) = string(N,10) + " " + toString(NL) [ owise ] . op toString : QidList -> String . eq toString((nil).QidList) = "" . eq toString(F FL) = string(F) + " " + toString(FL) [ owise ] . op toString : Module HookList -> String . eq toString(M, (nil).HookList) = "" . eq toString(M, id-hook(F,FL)) = if (FL == nil) then "id-hook " + string(F) else "id-hook " + string(F) + " (" + toString(FL) + ")" fi . eq toString(M, term-hook(F,T)) = "term-hook " + string(F) + " (" + toString(M,T) + ")" . eq toString(M, op-hook(F,F',FL,F'')) = "op-hook " + string(F) + " (" + string(F') + " : " + toString(FL) + " ~> " + string(F'') + ")" . eq toString(M, HK HKL) = toString(M,HK) + (if (HKL == nil) then "" else " " + toString(M,HKL) fi) [ owise ] . op toString : ParameterList -> String . eq toString((empty).ParameterList) = "" . eq toString(S) = string(S) . eq toString((S, PL)) = string(S) + ", " + toString(PL) [ owise ] . op toString : Module OpDeclSet -> String . eq toString(M,(none).OpDeclSet) = "" . eq toString(M,(op F : TYL -> TY [ ATS ] .)) = if (ATS == none) then " op " + string(F) + (if (TYL == nil) then " : -> " else " : " + toString(TYL) + " -> " fi) + cleanString(TY) + " .\n" else " op " + string(F) + (if (TYL == nil) then " : -> " else " : " + toString(TYL) + " -> " fi) + cleanString(TY) + " [ " + toString(M, ATS) + " ] .\n" fi . eq toString(M,OPD OPDS) = toString(M,OPD) + toString(M,OPDS) [ owise ] . op toString : Module MembAxSet -> String . eq toString(M,(none).MembAxSet) = "" . eq toString(M,(mb T : S [ ATS ] .)) = if (ATS == none) then " mb " + toString(M, T) + " : " + string(S) + " .\n" else " mb " + toString(M, T) + " : " + string(S) + " [ " + toString(M, ATS) + " ] .\n" fi . eq toString(M,(cmb T : S if COND [ ATS ] .)) = if (ATS == none) then " cmb " + toString(M, T) + " : " + string(S) + " if " + toString(M, COND) + " .\n" else " cmb " + toString(M, T) + " : " + string(S) + " if " + toString(M, COND) + " [ " + toString(M, ATS) + " ] .\n" fi . eq toString(M,MA MAS) = toString(M,MA) + toString(M,MAS) [ owise ] . op toString : Module EquationSet -> String . eq toString(M,(none).EquationSet) = "" . eq toString(M,(eq LHS = RHS [ ATS ] .)) = if (ATS == none) then " eq " + toString(M, LHS) + " = " + toString(M, RHS) + " .\n" else " eq " + toString(M, LHS) + " = " + toString(M, RHS) + " [ " + toString(M, ATS) + " ] .\n" fi . eq toString(M,(ceq LHS = RHS if COND [ ATS ] .)) = if (ATS == none) then " ceq " + toString(M, LHS) + " = " + toString(M, RHS) + " if " + toString(M, COND) + " .\n" else " ceq " + toString(M, LHS) + " = " + toString(M, RHS) + " if " + toString(M, COND) + " [ " + toString(M, ATS) + " ] .\n" fi . eq toString(M,EQ EQS) = toString(M,EQ) + toString(M,EQS) [ owise ] . op toString : Module RuleSet -> String . eq toString(M,(none).RuleSet) = "" . eq toString(M,(rl LHS => RHS [ ATS ] .)) = if (ATS == none) then " rl " + toString(M, LHS) + " => " + toString(M, RHS) + " .\n" else " rl " + toString(M, LHS) + " => " + toString(M, RHS) + " [ " + toString(M, ATS) + " ] .\n" fi . eq toString(M,(crl LHS => RHS if COND [ ATS ] .)) = if (ATS == none) then " crl " + toString(M, LHS) + " => " + toString(M, RHS) + " if " + toString(M, COND) + " .\n" else " crl " + toString(M, LHS) + " => " + toString(M, RHS) + " if " + toString(M, COND) + " [ " + toString(M, ATS) + " ] .\n" fi . eq toString(M,RL RLS) = toString(M,RL) + toString(M,RLS) [ owise ] . op toString : Module Condition -> String . eq toString(M,(nil).Condition) = "" . eq toString(M,(T : S)) = toString(M, T) + " : " + string(S) . eq toString(M,(T = T')) = if (T' == 'true.Bool) then toString(M, T) else toString(M, T) + " = " + toString(M, T') fi . eq toString(M,(T' := T)) = toString(M, T') + " := " + toString(M, T) . eq toString(M,(T => T')) = toString(M, T) + " => " + toString(M, T') . eq toString(M,COND /\ COND') = toString(M, COND) + " /\\ " + toString(M, COND') [ owise ] . op toString : Module StratDeclSet -> String . eq toString(M, (none).StratDeclSet) = "" . eq toString(M, (strat F : TYL @ TY [ ATS ] .)) = if (ATS == none) then " strat " + string(F) + (if (TYL == nil) then " : @ " else " : " + toString(TYL) + " @ " fi) + cleanString(TY) + " .\n" else " strat " + string(F) + (if (TYL == nil) then " : @ " else " : " + toString(TYL) + " @ " fi) + cleanString(TY) + " [ " + toString(M,ATS) + " ] .\n" fi . eq toString(M,STD STDS) = toString(M,STD) + toString(M, STDS) [ owise ] . op toString : Module StratDefSet -> String . eq toString(M, (none).StratDefSet) = "" . eq toString(M, (sd CST := STA [ ATS ] .)) = if (ATS == none) then " rl " + toString(M, CST) + " := " + toString(M, STA) + " .\n" else " rl " + toString(M, CST) + " := " + toString(M, STA) + " [ " + toString(M, ATS) + " ] .\n" fi . eq toString(M, (csd CST := STA if COND [ ATS ] .)) = if (ATS == none) then " csd " + toString(M, CST) + " := " + toString(M, STA) + " if " + toString(M, COND) + " .\n" else " csd " + toString(M, CST) + " := " + toString(M, STA) + " if " + toString(M, COND) + " [ " + toString(M, ATS) + " ] .\n" fi . eq toString(M,STDF STDFS) = toString(M, STDF) + toString(M, STDFS) [ owise ] . op toString : Module CallStrategy -> String . eq toString(M, F [[ empty ]]) = string(F) . eq toString(M, F [[ TL ]]) = string(F) + " [[ " + toString(M, TL) + " ]]" [ owise ] . op toString : Module StrategyList -> String . eq toString(M, (empty).StrategyList) = "" . eq toString(M, fail) = "fail" . eq toString(M, idle) = "idle" . eq toString(M, top(RAP)) = "top " + toString(M, RAP) . eq toString(M, match T s.t. COND) = "match " + toString(M, T) + " s.t. " + toString(M, COND) . eq toString(M, xmatch T s.t. COND) = "xmatch " + toString(M, T) + " s.t. " + toString(M, COND) . eq toString(M, amatch T s.t. COND) = "amatch " + toString(M, T) + " s.t. " + toString(M, COND) . eq toString(M, STA | STA') = toString(M, STA) + " | " + toString(M, STA') . eq toString(M, STA ; STA') = toString(M, STA) + " ; " + toString(M, STA') . eq toString(M, STA or-else STA') = toString(M, STA) + " or-else " + toString(M, STA') . eq toString(M, STA +) = toString(M, STA) + " +" . eq toString(M, STA ? STA' : STA'') = toString(M, STA) + " ? " + toString(M, STA') + " : " + toString(M, STA'') . eq toString(M, matchrew T s.t. COND by UPS) = "match " + toString(M, T) + " s.t. " + toString(M, COND) + " by " + toString(M, UPS) . eq toString(M, xmatchrew T s.t. COND by UPS) = "xmatch " + toString(M, T) + " s.t. " + toString(M, COND) + " by " + toString(M, UPS) . eq toString(M, amatchrew T s.t. COND by UPS) = "amatch " + toString(M, T) + " s.t. " + toString(M, COND) + " by " + toString(M, UPS) . eq toString(M, (STA)*) = "( " + toString(M, STA) + " )*" . eq toString(M, (STA)!) = "( " + toString(M, STA) + " )!" . eq toString(M, not(STA)) = "not(" + toString(M, STA) + ")" . eq toString(M, test(STA)) = "test(" + toString(M, STA) + ")" . eq toString(M, try(STA)) = "try( " + toString(M, STA) + ")" . eq toString(M, one(STA)) = "one(" + toString(M, STA) + ")" . eq toString(M, (STL , STL')) = toString(M, STL) + " ; " + toString(M, STL') [ owise ] . op toString : Module RuleApplication -> String . eq toString(M, all) = "all" . eq toString(M, F [ SB ]{ empty }) = string(F) + "[ " + toString(M, SB) + " ]" . eq toString(M, F [ SB ]{ STL }) = string(F) + "[ " + toString(M, SB) + " ]{ " + toString(M, STL) + " }" [ owise ] . op toString : Module UsingPairSet -> String . eq toString(M, V using STA) = toString(M, V) + " using " + toString(M, STA) . eq toString(M, (UPS , UPS')) = toString(M, UPS) + " , " + toString(M, UPS') [ owise ] . op toString : Module Substitution -> String . eq toString(M, (none).Substitution) = "" . eq toString(M, V <- T) = toString(M, V) + " <- " + toString(M, T) . eq toString(M, V <- T ; SB) = toString(M, V) + " <- " + toString(M, T) + ", " + toString(M, SB) [ owise ] . endfm fmod NuITP-REPORT is pr NuITP-STRING . op NuITP-R0 : -> String . eq NuITP-R0 = "%This report has been automatically generated by NuITP " + NuITP-VERSION + ".\n\n" . op NuITP-R1 : -> String . eq NuITP-R1 = "\\documentclass[10pt]{report}\n" + "\\usepackage[a4paper, left=2.5cm, right=2.5cm, top=3.75cm, bottom=3.75cm]{geometry}\n" + "\\usepackage[utf8]{inputenc}\n" + "\\usepackage{xcolor}\n" + "\\usepackage{forest}\n" + "\\usepackage{fancyvrb}\n" + "\\usepackage{fvextra}\n" + "\\usepackage{pdflscape}\n" + "\\usepackage{titlesec}\n" + "\\usepackage{adjustbox}\n" + "\\titleformat*{\\section}{\\normalfont\\fontfamily{phv}\\fontsize{10}{10}\\bfseries}\n" + "\\usepackage{fancyhdr}\n" + "\\usepackage{lastpage}\n" + "\\definecolor{applegreen}{rgb}{0.55, 0.71, 0.0}\n" + "\\pagestyle{fancy}\n" + "\\cfoot{\\thepage\\ of \\pageref{LastPage}}\n" + "\\renewcommand{\\headrulewidth}{1pt}\n" + "\\renewcommand{\\footrulewidth}{1pt}\n" + "\\fancyhf{}\n" . op NuITP-RSAT : -> String . eq NuITP-RSAT = "\\fancyhead[L]{\\fontfamily{phv}\\LARGE\\textbf{NuITP " + NuITP-VERSION + "\\hfill \\color{applegreen}Proved}}\n" . op NuITP-RUNSAT : -> String . eq NuITP-RUNSAT = "\\fancyhead[L]{\\fontfamily{phv}\\LARGE\\textbf{NuITP " + NuITP-VERSION + "\\hfill \\color{red}Not Proved}}\n" . op NuITP-R2 : -> String . eq NuITP-R2 = "\\fancyfoot[R]{\\thepage\\ of \\pageref{LastPage}}\n" + "\\begin{document}\n" + "\\small\n" + "\\section*{Goal}\n" + "\\begin{Verbatim}[breaklines=true]\n" . op NuITP-R3 : -> String . eq NuITP-R3 = "\n\\end{Verbatim}\n\n" + "\\section*{Script}\n" + "\\begin{Verbatim}[breaklines=true]\n" . op NuITP-R4 : -> String . eq NuITP-R4 = "\\end{Verbatim}\n\n" + "\\section*{Rewriting Theory}\n" + "\\begin{Verbatim}[breaklines=true]\n" . op NuITP-R5 : -> String . eq NuITP-R5 = "\n\\end{Verbatim}\n\n" + "\\section*{Proof Tree}\n" + "\\begin{Verbatim}[breaklines=true]" . op NuITP-R6 : -> String . eq NuITP-R6 = "\\end{Verbatim}\n" + "\\newpage\n" + "\\thispagestyle{empty}\n" + "\\begin{landscape}\n" + "\\centering\n" + "\\begin{adjustbox}{max width=\\linewidth}\n" + "\\begin{forest}\n" + "for tree={\n" + " rounded rectangle,\n" + " thick,\n" + " l sep=0.6cm,\n" + " s sep=0.6cm,\n" + " node options={draw,font=\\sffamily},\n" + " edge={semithick},\n" + " minimum height=1cm,\n" + " minimum width=1cm,\n" + " start/.style={\n" + " draw=black,\n" + " fill=blue!10,\n" + " double,\n" + " outer sep=1pt,\n" + " text height=1.5ex,\n" + " text depth=.25ex,\n" + " },\n" + " proved/.style={\n" + " draw=black,\n" + " fill=green!20,\n" + " text height=1.5ex,\n" + " text depth=.25ex,\n" + " },\n" + " open/.style={\n" + " draw=black,\n" + " fill=red!20,\n" + " text height=1.5ex,\n" + " text depth=.25ex,\n" + " },\n" + "label/.style={\n" + " edge label={\n" + " node [midway, fill=white, font=\\scriptsize] {#1}\n" + " }\n" + "}}\n" . op NuITP-R7 : -> String . eq NuITP-R7 = "\\end{forest}\n" + "\\end{adjustbox}\n" + "\\end{landscape}\n" + "\\end{document}\n" . vars M MO : Module . vars ID PID STR : String . vars SKO HPS : TermSet . vars CLA T TM TL TP TF : Term . var GS : GoalSet . vars MODNAME RID : Qid . var LOG : StringList . op getReport : Qid Term -> String . eq getReport(MODNAME, '_|_|_|_[TM,TL,TP,TF]) = getReport(upModule(MODNAME, false), downTerm(TM, (error).Module?), getGoal('_|_|_|_[TM,TL,TP,TF],"0"), downTerm(TL, (nil).StringList), getAllGoals('_|_|_|_[TM,TL,TP,TF]), (TF == 'mt.GoalSet)) . eq getReport(MODNAME, T) = "NuITP-ERROR" [ owise ] . op getReport : Module Module Goal StringList GoalSet Bool -> String . eq getReport(MO, M, { ID, RID, SKO, HPS, CLA }, LOG, GS, true) = NuITP-R0 + NuITP-R1 + NuITP-RSAT + NuITP-R2 + toStringCLA(M, CLA) + NuITP-R3 + getMinLog(LOG) + NuITP-R4 + toString(MO) + NuITP-R5 + toStringTeX(M, GS) + NuITP-R6 + getForest(ID, GS) + NuITP-R7 . eq getReport(MO, M, { ID, RID, SKO, HPS, CLA }, LOG, GS, false) = NuITP-R0 + NuITP-R1 + NuITP-RUNSAT + NuITP-R2 + toStringCLA(M, CLA) + NuITP-R3 + getMinLog(LOG) + NuITP-R4 + toString(MO) + NuITP-R5 + toStringTeX(M, GS) + NuITP-R6 + getForest(ID, GS) + NuITP-R7 . op getForest : String GoalSet -> String . eq getForest(ID, { ID, RID, SKO, HPS, CLA }) = "[{" + ID + "},start\n]" . eq getForest(ID, { ID, RID, SKO, HPS, CLA } GS) = "[{" + ID + "},start\n" + getForest(GS) + "]\n" [ owise ] . op getForest : GoalSet -> String . eq getForest(mt) = "" . eq getForest({ ID, RID, SKO, HPS, CLA } GS) = if getChildren(GS,ID) == mt then "[{" + ID + "}, label=" + string(RID) + ", " + if (CLA == 'true.NuITP-Bool) then "proved" else "open" fi + "]\n" + getForest(GS) else "[{" + ID + "}, label=" + string(RID) + "\n" + getForest(getChildren(GS,ID)) + "]\n" + getForest(removeGoals(getChildren(GS,ID), GS)) fi [ owise ] . endfm fmod NuITP-SYNTAX-GENSET is pr QID-LIST . sorts Term TermSet Bubble . subsort Term < TermSet . op bubble : QidList -> Bubble [ special (id-hook Bubble (1 -1) op-hook qidListSymbol (__ : QidList QidList ~> QidList) op-hook qidSymbol ( : ~> Qid) id-hook Exclude ( ;; )) ] . op _;;_ : TermSet TermSet -> TermSet [ ctor ] . op _;;_ : Bubble TermSet -> TermSet [ ctor ] . op _;;_ : Bubble Bubble -> TermSet [ ctor ] . endfm fmod NuITP-SYNTAX-DISJUNCTION is pr QID-LIST . sorts Eq Disjunction Bubble . subsort Eq < Disjunction . op bubble : QidList -> Bubble [ special (id-hook Bubble (1 -1) op-hook qidListSymbol (__ : QidList QidList ~> QidList) op-hook qidSymbol ( : ~> Qid) id-hook Exclude ( \/ = )) ] . op _\/_ : Disjunction Disjunction -> Disjunction [ ctor ] . op _\/_ : Eq Disjunction -> Disjunction [ ctor ] . op _\/_ : Eq Eq -> Disjunction [ ctor ] . op _=_ : Bubble Bubble -> Eq [ ctor ] . endfm fmod NuITP-SYNTAX-SUBSTITUTION is pr QID-LIST . sorts Variable Term Assignment Substitution Substitution? Token Bubble . subsort Assignment < Substitution < Substitution? . op token : Qid -> Token [ special (id-hook Bubble (1 1) op-hook qidSymbol ( : ~> Qid)) ] . op bubble : QidList -> Bubble [ special (id-hook Bubble (1 -1) op-hook qidListSymbol (__ : QidList QidList ~> QidList) op-hook qidSymbol ( : ~> Qid) id-hook Exclude ( <- ; )) ] . op _<-_ : Token Bubble -> Assignment [ ctor prec 63 ] . op none : -> Substitution [ ctor ] . op _;_ : Substitution Substitution -> Substitution [ ctor assoc comm id: none prec 65 gather(e E) ] . endfm fmod NuITP-PARSE is pr NuITP-UTILS . var M : Module . var N : Nat . var Q : Qid . var QL : QidList . vars T T' GAMMA DELTA LHS RHS : Term . var NTL : NeTermList . var TY : Type . op downQidTermList : TermList -> QidList . eq downQidTermList(empty) = nil . eq downQidTermList(Q) = downTerm(Q, nil) . eq downQidTermList((Q,NTL)) = downQidTermList(Q) downQidTermList(NTL) . op parseTerm : Module QidList -> [Term] . eq parseTerm(M, QL) = getTerm(metaParse(M, none, QL, anyType)) . op parseClause : Module QidList -> [Term] . ceq parseClause(M, QL) = getTerm(metaNormalize(M, '_->_[GAMMA, DELTA])) if '_->_[GAMMA,DELTA] := getTerm(metaParse(M, none, QL, anyType)) . ceq parseClause(M, QL) = getTerm(metaNormalize(M, '_->_['true.NuITP-Bool, getTerm(metaParse(M, none, QL, anyType))])) if getTerm(metaParse(M, none, QL, anyType)) :: Term . op parseEquality : Module QidList -> [Term] . ceq parseEquality(M, QL) = getTerm(metaParse(M, none, QL, anyType)) if '_->_[GAMMA,'_=>_[LHS,RHS]] := getTerm(metaParse(M, none, QL, anyType)) . ceq parseEquality(M, QL) = getTerm(metaParse(M, none, QL, anyType)) if '_=>_[LHS,RHS] := getTerm(metaParse(M, none, QL, anyType)) . op parseSkolemSet : Module QidList -> [TermSet] . eq parseSkolemSet(M, nil) = mt . eq parseSkolemSet(M, QL) = if (getTerm(metaParse(omega(M), none, QL, anyType)) :: Term) then getTerm(metaParse(omega(M), none, QL, anyType)) else parseSkolemSet'(M, metaParse(upModule('NuITP-SYNTAX-GENSET,false), none, QL, anyType)) fi . op parseSkolemSet' : Module ResultPair? -> [TermSet] . eq parseSkolemSet'(M, { T , 'TermSet }) = parseSkolemSet''(M, T) . eq parseSkolemSet'(M, ambiguity({ T , 'TermSet },{ T' , 'TermSet})) = parseSkolemSet''(M, T) . op parseSkolemSet'' : Module Term -> [TermSet] . eq parseSkolemSet''(M, '_;;_[T,T']) = parseSkolemSet''(M, T) ;; parseSkolemSet''(M, T'). eq parseSkolemSet''(M, 'bubble['__[NTL]]) = parseSkolemSet(M, downQidTermList(NTL)) . eq parseSkolemSet''(M, 'bubble[T]) = getTerm(metaParse(omega(M), downQidTermList(T), anyType)) [ owise ] . op parseGenSet : Module Type QidList -> [TermSet] . eq parseGenSet(M, TY, nil) = mt . eq parseGenSet(M, TY, QL) = if (getTerm(metaParse(omega(M), none, QL, anyType)) :: Term) and-then sortLeq(M, getType(metaParse(omega(M), none, QL, anyType)), TY) then getTerm(metaParse(omega(M), none, QL, anyType)) else parseGenSet'(M, TY, metaParse(upModule('NuITP-SYNTAX-GENSET,false), none, QL, anyType)) fi . op parseGenSet' : Module Type ResultPair? -> [TermSet] . eq parseGenSet'(M, TY, { T , 'TermSet }) = parseGenSet''(M, TY, T) . eq parseGenSet'(M, TY, ambiguity({ T , 'TermSet },{ T' , 'TermSet})) = parseGenSet''(M, TY, T) . op parseGenSet'' : Module Type Term -> [TermSet] . eq parseGenSet''(M, TY, '_;;_[T,T']) = parseGenSet''(M, TY, T) ;; parseGenSet''(M, TY, T'). eq parseGenSet''(M, TY, 'bubble['__[NTL]]) = parseGenSet(M, TY, downQidTermList(NTL)) . ceq parseGenSet''(M, TY, 'bubble[T]) = getTerm(metaParse(omega(M), downQidTermList(T), anyType)) if sortLeq(M, getType(metaParse(omega(M), downQidTermList(T), anyType)), TY) [ owise ] . op parseDisjunction : Module QidList -> [Term] . eq parseDisjunction(M, QL) = getTerm(metaNormalize(M, parseDisjunction'(M, metaParse(upModule('NuITP-SYNTAX-DISJUNCTION,false), none, QL, anyType)))) . op parseDisjunction' : Module ResultPair? -> [Term] . eq parseDisjunction'(M, { T , 'Disjunction }) = parseDisjunction''(M, T) . eq parseDisjunction'(M, ambiguity({ T, 'Disjunction }, { T' , Q })) = parseDisjunction''(M, T) . op parseDisjunction'' : Module Term -> [Term] . eq parseDisjunction''(M, '_\/_[T,T']) = '_\/_[parseDisjunction''(M, T),parseDisjunction''(M, T')] . eq parseDisjunction''(M, '_=_[T,T']) = '_=_[parseDisjunction''(M, T),parseDisjunction''(M, T')] . eq parseDisjunction''(M, 'bubble['__[NTL]]) = getTerm(metaParse(M, downQidTermList(NTL), anyType)) . eq parseDisjunction''(M, 'bubble[T]) = getTerm(metaParse(M, downQidTermList(T), anyType)) [ owise ] . op parseSubstitution : Module QidList -> [Substitution] . eq parseSubstitution(M, nil) = none . eq parseSubstitution(M, QL) = parseSubstitution'(M, metaParse(upModule('NuITP-SYNTAX-SUBSTITUTION,false), none, QL, anyType)) . op parseSubstitution' : Module ResultPair? -> [Substitution] . eq parseSubstitution'(M, ambiguity({ T , 'Assignment},{ T' , 'Substitution })) = parseSubstitution''(M, getTerm(metaNormalize(upModule('NuITP-SYNTAX-SUBSTITUTION,false),T'))) . eq parseSubstitution'(M, { T , 'Assignment }) = parseSubstitution''(M, getTerm(metaNormalize(upModule('NuITP-SYNTAX-SUBSTITUTION,false),T))) . eq parseSubstitution'(M, { T , 'Substitution }) = parseSubstitution''(M, getTerm(metaNormalize(upModule('NuITP-SYNTAX-SUBSTITUTION,false),T))) . op parseSubstitution'' : Module NeTermList -> [Substitution] . eq parseSubstitution''(M, 'none.Substitution) = none . eq parseSubstitution''(M, '_<-_['token[Q],'bubble['__[NTL]]]) = downTerm(Q, nil) <- getTerm(metaParse(M, downQidTermList(NTL), anyType)) . eq parseSubstitution''(M, '_<-_['token[Q],'bubble[T]]) = downTerm(Q, nil) <- getTerm(metaParse(M, downQidTermList(T), anyType)) [ owise ] . eq parseSubstitution''(M, '_;_[NTL]) = parseSubstitution''(M, NTL) . eq parseSubstitution''(M, (T,NTL)) = parseSubstitution''(M, T) ; parseSubstitution''(M, NTL) . endfm fmod NuITP-SYNTAX is pr QID-LIST . sorts Token Bubble NuITP-Command . op token : Qid -> Token [ special (id-hook Bubble (1 1) op-hook qidSymbol ( : ~> Qid)) ] . op bubble : QidList -> Bubble [ special (id-hook Bubble (1 -1) op-hook qidListSymbol (__ : QidList QidList ~> QidList) op-hook qidSymbol ( : ~> Qid) id-hook Exclude (.)) ] . op q : -> NuITP-Command . op quit : -> NuITP-Command . op help : -> NuITP-Command . op load_ : Token -> NuITP-Command . op save_ : Token -> NuITP-Command . op export_ : Token -> NuITP-Command . op show`log`. : -> NuITP-Command . op show`module`. : -> NuITP-Command . op show`goals`. : -> NuITP-Command . op show`frontier`. : -> NuITP-Command . op show`goal_. : Token -> NuITP-Command . op set`module_. : Token -> NuITP-Command . op set`goal_. : Bubble -> NuITP-Command . op set`goal_skolem_. : Bubble Bubble -> NuITP-Command . op apply_to_. : Token Token -> NuITP-Command . --- Others op apply_to_with_. : Token Token Bubble -> NuITP-Command . --- EQ, EQ!, LE, LE! op apply_to_with_sub_. : Token Token Bubble Bubble -> NuITP-Command . --- EQ, EQ!, SP, SP! op apply_to_on_. : Token Token Bubble -> NuITP-Command . --- NI, NI!, VA, VA! op apply_to_on_with_. : Token Token Bubble Bubble -> NuITP-Command . --- GSI, GSI!, CAS, CAS! op undo_. : Token -> NuITP-Command . endfm mod NuITP is pr FILE . pr STD-STREAM . pr NuITP-REPORT . pr NuITP-PARSE . pr NuITP-INDUCTION-RULES . op NuITP : -> Cid [ ctor ] . op prover : -> Oid [ ctor ] . op writer : -> Oid [ ctor ] . op module:_ : Qid -> Attribute [ ctor prec 20 gather (&) ] . op proof:_ : Term -> Attribute [ ctor prec 20 gather (&) ] . op mode:_ : Oid -> Attribute [ ctor prec 20 gather (&) ] . op user : -> Oid [ ctor ] . op auto : Oid -> Oid [ ctor ] . op state:_ : Oid -> Attribute [ ctor prec 20 gather (&) ] . op idle : -> Oid [ ctor ] . op script : -> Oid [ ctor ] . op report : -> Oid [ ctor ] . op parse : String Term -> Msg [ ctor ] . vars M M' EXT-MODULE : Module . vars ATS ATS' : AttributeSet . var Q MODNAME RULE CMD : Qid . vars QL QL' : QidList . vars STR GID : String . vars T PROOF GOAL GAMMA DELTA EQUALITY LEMMA DISJ SUB NAWEX TERM VAR GENSET : Term . vars TL TL' GEN ARGS : TermList . var NTL : NeTermList . var N : Nat . var B : Bool . var NZ : NzNat . vars FH FH' OID OID' MODE : Oid . var CONF : Configuration . var SB : Substitution . vars PARSED-VAR PARSED-GOAL PARSED-EQUALITY PARSED-LEMMA PARSED-DISJ PARSED-TERM : [Term] . var PARSED-GENSET : [TermSet] . var PARSED-SUB : [Substitution] . op init : -> Configuration . eq init = <> < writer : NuITP | state: idle > < prover : NuITP | module: 'noModule, proof: '_|_|_|_[upTerm(extModule('NuITP-BOOL)),'"".String,'mt.GoalSet,'mt.GoalSet], mode: user > write(stdout, prover, WHITE + "\n\n NuITP \n Inductive Theorem Prover\n for Maude Equational Theories\n " + NuITP-VERSION + "\n\n\n" + BW) . --- quit rl < writer : NuITP | ATS > < prover : NuITP | ATS' , mode: MODE > parse(STR, 'q.NuITP-Command) => (none).Configuration write(stdout, prover, (if (MODE == user) then "\n" else "" fi) + WHITE + " Bye." + BW + "\n\n") . rl < writer : NuITP | ATS > < prover : NuITP | ATS' , mode: MODE > parse(STR, 'quit.NuITP-Command) => (none).Configuration write(stdout, prover, (if (MODE == user) then "\n" else "" fi) + WHITE + " Bye." + BW + "\n\n") . --- interaction rl < prover : NuITP | ATS , mode: user > wrote(prover, stdout) => < prover : NuITP | ATS , mode: user > getLine(stdin, prover, "NuITP> ") . rl < prover : NuITP | ATS , mode: auto(FH) > wrote(prover, stdout) => < prover : NuITP | ATS , mode: auto(FH) > getLine(FH, prover) . rl < writer : NuITP | state: idle > < prover : NuITP | ATS , mode: user > gotLine(prover, stdin, STR) => < writer : NuITP | state: idle > < prover : NuITP | ATS , mode: user > parse(STR, disambiguate(getTerm(metaParse(upModule('NuITP-SYNTAX,false), none, tokenize(STR), 'NuITP-Command)))) . rl < writer : NuITP | state: idle > < prover : NuITP | ATS , mode: auto(FH) > gotLine(prover, FH, STR) => if (STR == "") then < writer : NuITP | state: idle > < prover : NuITP | ATS , mode: user > write(stdout, prover, YELLOW + " End running script." + BW + "\n\n") closeFile(FH, prover) else < writer : NuITP | state: idle > < prover : NuITP | ATS , mode: auto(FH) > if (substr(STR,0,1) == "#") then getLine(FH, prover) else parse(STR, disambiguate(getTerm(metaParse(upModule('NuITP-SYNTAX,false), none, tokenize(STR), 'NuITP-Command)))) fi fi . op disambiguate : Term -> Term . eq disambiguate(getTerm(ambiguity({'set`goal_.[TL],'NuITP-Command}, {'set`goal_skolem_.[TL'],'NuITP-Command}))) = 'set`goal_skolem_.[TL'] . eq disambiguate(getTerm(ambiguity({'apply_to_on_.[TL],'NuITP-Command}, {'apply_to_on_with_.[TL'],'NuITP-Command}))) = 'apply_to_on_with_.[TL'] . eq disambiguate(getTerm(ambiguity({'apply_to_with_.[TL],'NuITP-Command}, {'apply_to_with_sub_.[TL'],'NuITP-Command}))) = 'apply_to_with_sub_.[TL'] . eq disambiguate(T:[Term]) = T:[Term] [ owise ] . --- parsing errors eq < prover : NuITP | ATS , mode: user > parse(STR, getTerm(noParse(N))) = < prover : NuITP | ATS , mode: user > write(stdout, prover, "\n" + RED + " Error parsing command." + BW + "\n\n") . eq < prover : NuITP | ATS , mode: auto(FH) > parse("", getTerm(noParse(0))) = < prover : NuITP | ATS , mode: user > write(stdout, prover, YELLOW + " End running script." + BW + "\n\n") closeFile(FH, prover) . eq < prover : NuITP | ATS , mode: auto(FH) > parse(STR, getTerm(noParse(N))) = < prover : NuITP | ATS , mode: user > write(stdout, prover, RED + " Error parsing command. Aborting script." + BW + "\n\n") closeFile(FH, prover) . eq closedFile(OID, FH) = none . --- load script rl < prover : NuITP | ATS, mode: auto(FH) > parse(STR, 'load_['token[T]]) => < prover : NuITP | ATS, mode: auto(FH) > write(stdout, prover, RED + " Unable to load a script from another script." + BW + "\n\n") . rl < prover : NuITP | ATS, mode: user > parse(STR, 'load_['token[T]]) => < prover : NuITP | ATS, mode: user > openFile(fileManager, prover, string(downTerm(T,'noFileName.Qid)), "r") . rl < prover : NuITP | ATS, mode: user > openedFile(prover, fileManager, FH) => < prover : NuITP | ATS, mode: auto(FH) > write(stdout, prover, "\n" + YELLOW + " Begin running script." + BW + "\n\n") . --- save script rl < writer : NuITP | state: idle > < prover : NuITP | ATS > parse(STR, 'save_['token[T]]) => < writer : NuITP | state: script > < prover : NuITP | ATS > openFile(fileManager, writer, string(downTerm(T,'noFileName.Qid)), "w") . rl < writer : NuITP | state: script > < prover : NuITP | ATS, proof: PROOF > openedFile(writer, fileManager, FH) => < writer : NuITP | state: script > < prover : NuITP | ATS, proof: PROOF > write(FH, writer, "#\n# NuITP " + NuITP-VERSION + " script file\n#\n" + getMinLog(PROOF)) . rl < writer : NuITP | state: script > < prover : NuITP | ATS, mode: MODE > wrote(writer, FH) => < writer : NuITP | state: idle > < prover : NuITP | ATS, mode: MODE > write(stdout, prover, (if (MODE == user) then "\n" else "" fi) + CYAN + " Script successfully saved." + BW + "\n\n") closeFile(FH, writer) . --- save report rl < writer : NuITP | state: idle > < prover : NuITP | ATS, proof: PROOF, mode: MODE > parse(STR, 'export_['token[T]]) => if (getGoal(PROOF,"0") :: Goal) then < writer : NuITP | state: report > < prover : NuITP | ATS, proof: PROOF, mode: MODE > openFile(fileManager, writer, string(downTerm(T,'noFileName.Qid)) + ".tex", "w") else < writer : NuITP | state: idle > < prover : NuITP | ATS, proof: PROOF, mode: MODE > write(stdout, prover, (if (MODE == user) then "\n" else "" fi) + RED + " No session started." + BW + "\n\n") fi . rl < writer : NuITP | state: report > < prover : NuITP | ATS, module: MODNAME, proof: PROOF > openedFile(writer, fileManager, FH) => < writer : NuITP | state: report > < prover : NuITP | ATS, module: MODNAME, proof: PROOF > write(FH, writer, getReport(MODNAME, PROOF) + "\n") . rl < writer : NuITP | state: report > < prover : NuITP | ATS, mode: MODE > wrote(writer, FH) => < writer : NuITP | state: idle > < prover : NuITP | ATS, mode: MODE > write(stdout, prover, (if (MODE == user) then "\n" else "" fi) + CYAN + " TeX report successfully generated." + BW + "\n\n") closeFile(FH, writer) . --- I/O error handler rl < prover : NuITP | ATS, mode: user > fileError(prover, FH, STR) => if (STR == "File operations disabled.") then < prover : NuITP | ATS, mode: user > write(stdout, prover, "\n" + RED + " " + STR + " Use the -trust flag when starting Maude to enable them." + BW + "\n\n") else < prover : NuITP | ATS, mode: user > write(stdout, prover, "\n" + RED + " " + STR + BW + "\n\n") fi . --- Help rl < prover : NuITP | ATS > parse(STR, 'help.NuITP-Command) => < prover : NuITP | ATS > write(stdout, prover, help-message) . op help-message : -> String . eq help-message = "\n" + GREEN + " Available commands:" + BW + "\n\n" + " " + CYAN + "q" + BW + " or " + CYAN + "quit" + BW + ": quits NuITP.\n" + " " + CYAN + "help" + BW + ": shows this info.\n" + "\n" + " " + CYAN + "show log ." + BW + ": shows the session log.\n" + " " + CYAN + "show module ." + BW + ": shows the active module.\n" + " " + CYAN + "show goals ." + BW + ": shows all goals.\n" + " " + CYAN + "show frontier ." + BW + ": shows the goals in the frontier.\n" + " " + CYAN + "show goal " + WHITE + "" + CYAN + " ." + BW + ": shows the specified goal.\n" + "\n" + " " + CYAN + "set module " + WHITE + "" + CYAN + " ." + BW + ": sets the specified module as active module.\n" + " " + CYAN + "set goal " + WHITE + "" + CYAN + " ." + BW + ": sets the specified goal as active goal.\n" + " " + CYAN + "undo " + WHITE + "" + CYAN + " ." + BW + ": undoes any previous rule application to the goal.\n" + "\n" + " " + CYAN + "load " + WHITE + "" + BW + ": loads and runs the NuITP script of the given file.\n" + " " + CYAN + "save " + WHITE + "" + BW + ": saves the session log into a script file.\n" + " " + CYAN + "export " + WHITE + "" + BW + ": creates a LaTeX file with a summary of the current session.\n" + "\n" + " " + CYAN + "apply " + WHITE + "" + CYAN + " to " + WHITE + "" + CYAN + " ." + BW + ": applies the specified simplification rule on the specified goal.\n" + "\n" + " " + CYAN + "apply eq to " + WHITE + "" + CYAN + " with " + WHITE + "" + CYAN + " ." + BW + ": " + getRuleMsg(''eq.Qid) + "\n" + " " + CYAN + "apply eq to " + WHITE + "" + CYAN + " with " + WHITE + "" + CYAN + " sub " + WHITE + "" + CYAN + " ." + BW + ": " + getRuleMsg(''eq.Qid) + "\n" + " " + CYAN + "apply gsi to " + WHITE + "" + CYAN + " on " + WHITE + "" + CYAN + " with " + WHITE + "" + CYAN + " ." + BW + ": " + getRuleMsg(''gsi.Qid) + "\n" + " " + CYAN + "apply ni to " + WHITE + "" + CYAN + " on " + WHITE + "" + CYAN + " ." + BW + ": " + getRuleMsg(''ni.Qid) + "\n" + " " + CYAN + "apply le to " + WHITE + "" + CYAN + " with " + WHITE + "" + CYAN + " ." + BW + ": " + getRuleMsg(''le.Qid) + "\n" + " " + CYAN + "apply sp to " + WHITE + "" + CYAN + " with " + WHITE + "" + CYAN + " sub " + WHITE + "" + CYAN + " ." + BW + ": " + getRuleMsg(''sp.Qid) + "\n" + " " + CYAN + "apply cas to " + WHITE + "" + CYAN + " on " + WHITE + "" + CYAN + " with " + WHITE + "" + CYAN + " ." + BW + ": " + getRuleMsg(''cas.Qid) + "\n" + " " + CYAN + "apply va to " + WHITE + "" + CYAN + " on " + WHITE + "" + CYAN + " ." + BW + ": " + getRuleMsg(''va.Qid) + "\n" + "\n" + " " + CYAN + "apply eq! to " + WHITE + "" + CYAN + " with " + WHITE + "" + CYAN + " ." + BW + ": " + getRuleMsg(''eq!.Qid) + "\n" + " " + CYAN + "apply eq! to " + WHITE + "" + CYAN + " with " + WHITE + "" + CYAN + " sub " + WHITE + "" + CYAN + " ." + BW + ": " + getRuleMsg(''eq!.Qid) + "\n" + " " + CYAN + "apply gsi! to " + WHITE + "" + CYAN + " on " + WHITE + "" + CYAN + " with " + WHITE + "" + CYAN + " ." + BW + ": " + getRuleMsg(''gsi!.Qid) + "\n" + " " + CYAN + "apply ni! to " + WHITE + "" + CYAN + " on " + WHITE + "" + CYAN + " ." + BW + ": " + getRuleMsg(''ni!.Qid) + "\n" + " " + CYAN + "apply le! to " + WHITE + "" + CYAN + " with " + WHITE + "" + CYAN + " ." + BW + ": " + getRuleMsg(''le!.Qid) + "\n" + " " + CYAN + "apply sp! to " + WHITE + "" + CYAN + " with " + WHITE + "" + CYAN + " sub " + WHITE + "" + CYAN + " ." + BW + ": " + getRuleMsg(''sp!.Qid) + "\n" + " " + CYAN + "apply cas! to " + WHITE + "" + CYAN + " on " + WHITE + "" + CYAN + " with " + WHITE + "" + CYAN + " ." + BW + ": " + getRuleMsg(''cas!.Qid) + "\n" + " " + CYAN + "apply va! to " + WHITE + "" + CYAN + " on " + WHITE + "" + CYAN + " ." + BW + ": " + getRuleMsg(''va!.Qid) + "\n" + "\n" + GREEN + " The simplification rules are:" + BW + "\n\n" + " " + CYAN + "eps" + BW + ": " + getRuleMsg(''eps.Qid) + "\n" + " " + CYAN + "cvul" + BW + ": " + getRuleMsg(''cvul.Qid) + "\n" + " " + CYAN + "cvufr" + BW + ": " + getRuleMsg(''cvufr.Qid) + "\n" + " " + CYAN + "subl" + BW + ": " + getRuleMsg(''subl.Qid) + "\n" + " " + CYAN + "subr" + BW + ": " + getRuleMsg(''subr.Qid) + "\n" + " " + CYAN + "cs" + BW + ": " + getRuleMsg(''cs.Qid) + "\n" + " " + CYAN + "icc" + BW + ": " + getRuleMsg(''icc.Qid) + "\n" + " " + CYAN + "varsat" + BW + ": " + getRuleMsg(''varsat.Qid) + "\n" + "\n" . --- error handling op error : Configuration String Bool -> Configuration . eq error(< prover : NuITP | ATS, mode: auto(FH) >, STR, true) = < prover : NuITP | ATS, mode: user > write(stdout, prover, RED + " " + STR + " Aborting script." + BW + "\n\n") closeFile(FH, prover) . eq error(< prover : NuITP | ATS, mode: auto(FH) >, STR, false) = < prover : NuITP | ATS, mode: auto(FH) > write(stdout, prover, RED + " " + STR + BW + "\n\n") . eq error(< prover : NuITP | ATS >, STR, B) = < prover : NuITP | ATS > write(stdout, prover, "\n" + RED + " " + STR + BW + "\n\n") [ owise ] . op message : Oid Oid Oid String -> Configuration . eq message(OID, OID', user, STR) = write(OID, OID', "\n" + CYAN + " " + STR + BW + "\n\n") . eq message(OID, OID', MODE, STR) = write(OID, OID', CYAN + " " + STR + BW + "\n\n") [ owise ] . --- set module MODNAME . rl < prover : NuITP | ATS, module: MODNAME, mode: MODE > parse(STR, 'set`module_.['token[T]]) => if upModule(downTerm(T, 'noModule.Qid),false) :: Module then < prover : NuITP | ATS, module: downTerm(T,'noModule.Qid), mode: MODE > message(stdout, prover, MODE, "Module " + string(downTerm(T, 'noModule.Qid)) + " is now active.") else error(< prover : NuITP | ATS, module: MODNAME, mode: MODE >, "Module " + string(downTerm(T, 'noModule.Qid)) + " is not available.", true) fi . --- set goal GOAL . rl < prover : NuITP | ATS, module: MODNAME, proof: PROOF, mode: MODE > parse(STR, 'set`goal_.['bubble[TL]]) => if (MODNAME == 'noModule) then error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF, mode: MODE >, "No module loaded.", true) else if parseClause(extModule(MODNAME), downTerm(TL, 'noTerm.QidList)) :: Term then < prover : NuITP | ATS, module: MODNAME, proof: '_|_|_|_[upTerm(extModule(MODNAME)),upTerm("set module " + string(MODNAME) + " .\n" STR),'mt.GoalSet,upTerm({ "0", 'init, mt, mt, parseClause(extModule(MODNAME), downTerm(TL, 'noTerm.QidList)) })], mode: MODE > write(stdout, prover, (if (MODE == user) then "\n" else "" fi) + CYAN + " Initial goal set." + BW + "\n\n" + toString(extModule(MODNAME), { "0", 'init, mt, mt, parseClause(extModule(MODNAME), downTerm(TL, 'noTerm.QidList)) })) else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF, mode: MODE >, "Error parsing goal.", true) fi fi . --- set goal GOAL skolem TERMSET . rl < prover : NuITP | ATS, module: MODNAME, proof: PROOF, mode: MODE > parse(STR, 'set`goal_skolem_.['bubble[TL],'bubble[TL']]) => if (MODNAME == 'noModule) then error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF, mode: MODE >, "No module loaded.", true) else if freeze(parseSkolemSet(extModule(MODNAME), downTerm(TL','nil.QidList))) :: TermSet then if parseClause(addOps(extModule(MODNAME), freeze(parseSkolemSet(extModule(MODNAME), downTerm(TL','nil.QidList)))), downTerm(TL, 'noTerm.QidList)) :: Term then < prover : NuITP | ATS, module: MODNAME, proof: '_|_|_|_[upTerm(extModule(MODNAME)), upTerm("set module " + string(MODNAME) + " .\n" STR), 'mt.GoalSet, upTerm({ "0", 'init, freeze(parseSkolemSet(extModule(MODNAME), downTerm(TL','nil.QidList))), mt, parseClause(addOps(extModule(MODNAME), freeze(parseSkolemSet(extModule(MODNAME), downTerm(TL','nil.QidList)))), downTerm(TL, 'noTerm.QidList)) })], mode: MODE > write(stdout, prover, (if (MODE == user) then "\n" else "" fi) + CYAN + " Initial goal set." + BW + "\n\n" + toString(extModule(MODNAME), { "0", 'init, freeze(parseSkolemSet(extModule(MODNAME), downTerm(TL','nil.QidList))), mt, parseClause(addOps(extModule(MODNAME), freeze(parseSkolemSet(extModule(MODNAME), downTerm(TL','nil.QidList)))), downTerm(TL, 'noTerm.QidList)) })) else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF, mode: MODE >, "Error parsing goal.", true) fi else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF, mode: MODE >, "Error parsing skolem variables.", true) fi fi . --- show log . rl < prover : NuITP | ATS, proof: PROOF, mode: MODE > parse(STR, 'show`log`..NuITP-Command) => < prover : NuITP | ATS, proof: PROOF, mode: MODE > if (getLog(PROOF) == "") then message(stdout, prover, MODE, "Log is empty.") else write(stdout, prover, (if (MODE == user) then "\n" else "" fi) + CYAN + " NuITP log for this session:" + BW + "\n\n" + getLog(PROOF) + "\n") fi . --- show module . rl < prover : NuITP | ATS, module: MODNAME, mode: MODE > parse(STR, 'show`module`..NuITP-Command) => if (MODNAME == 'noModule) then error(< prover : NuITP | ATS, module: MODNAME, mode: MODE >, "No module loaded.", false) else < prover : NuITP | ATS, module: MODNAME, mode: MODE > message(stdout, prover, MODE, "Module " + string(MODNAME) + " is active.") fi . --- show goals . rl < prover : NuITP | ATS, proof: PROOF, mode: MODE > parse(STR, 'show`goals`..NuITP-Command) => if (getAllGoals(PROOF) == mt) then error(< prover : NuITP | ATS, proof: PROOF, mode: MODE >, "There are no goals.", false) else < prover : NuITP | ATS, proof: PROOF, mode: MODE > write(stdout, prover, (if (MODE == user) then "\n" else "" fi) + toString(getModule(PROOF),getAllGoals(PROOF))) fi . --- show frontier . rl < prover : NuITP | ATS, proof: PROOF, mode: MODE > parse(STR, 'show`frontier`..NuITP-Command) => < prover : NuITP | ATS, proof: PROOF, mode: MODE > if (getFrontier(PROOF) == mt) then message(stdout, prover, MODE, "Frontier is empty.") else write(stdout, prover, (if (MODE == user) then "\n" else "" fi) + toString(getModule(PROOF),getFrontier(PROOF))) fi . --- show goal GID . rl < prover : NuITP | ATS, proof: PROOF, mode: MODE > parse(STR, 'show`goal_.['token[T]]) => if getGoal(PROOF,T) :: Goal then < prover : NuITP | ATS, proof: PROOF, mode: MODE > write(stdout, prover, (if (MODE == user) then "\n" else "" fi) + toString(getModule(PROOF),getGoal(PROOF,T))) else error(< prover : NuITP | ATS, proof: PROOF, mode: MODE >, "Goal does not exist.", false) fi . --- undo GID . rl < prover : NuITP | ATS, proof: PROOF, mode: MODE > parse(STR, 'undo_.['token[T]]) => if getGoal(PROOF,T) :: Goal then if isProved(getGoal(PROOF,T)) then error(< prover : NuITP | ATS, proof: PROOF, mode: MODE >, "Goal " + getGID(T) + " is proved. Unable to undo.", false) else if (getChildren(PROOF, getGID(T)) == mt) then error(< prover : NuITP | ATS, proof: PROOF, mode: MODE >, "Goal " + getGID(T) + " is in the frontier. Unable to undo.", false) else < prover : NuITP | ATS, proof: deleteGoal(PROOF, getGID(T)), mode: MODE > message(stdout, prover, MODE, "Goal " + getGID(T) + " undone. All its children have been deleted.") fi fi else error(< prover : NuITP | ATS, proof: PROOF, mode: MODE >, "Goal does not exist.", false) fi . op getRuleMsg : Term -> String . --- Simplification Rules eq getRuleMsg(''eps.Qid) = "Equality Predicate Simplification (EPS)" . eq getRuleMsg(''cvul.Qid) = "Constructor Variant Unification Left (CVUL)" . eq getRuleMsg(''cvufr.Qid) = "Constructor Variant Unification Failure Right (CVUFR)" . eq getRuleMsg(''subl.Qid) = "Substitution Left (SUBL)" . eq getRuleMsg(''subr.Qid) = "Substitution Right (SUBR)" . eq getRuleMsg(''ns.Qid) = "Narrowing Simplification (NS)" . eq getRuleMsg(''cs.Qid) = "Clause Subsumption (CS)" . eq getRuleMsg(''icc.Qid) = "Inductive Congruence Closure (ICC)" . eq getRuleMsg(''varsat.Qid) = "Variant Satisfiability (VARSAT)" . eq getRuleMsg(''eq.Qid) = "Equality (EQ)" . eq getRuleMsg(''eq!.Qid) = "Equality with Equality Predicate Simplification (EQ!)" . --- Inductive Rules eq getRuleMsg(''gsi.Qid) = "Generator Set Induction (GSI)" . eq getRuleMsg(''ni.Qid) = "Narrowing Induction (NI)" . eq getRuleMsg(''le.Qid) = "Lemma Enrichment (LE)" . eq getRuleMsg(''sp.Qid) = "Split (SP)" . eq getRuleMsg(''cas.Qid) = "Case (CAS)" . eq getRuleMsg(''va.Qid) = "Variable Abstraction (VA)" . --- Inductive Rules with EPS simplification eq getRuleMsg(''gsi!.Qid) = "Generator Set Induction with Equality Predicate Simplification (GSI!)" . eq getRuleMsg(''ni!.Qid) = "Narrowing Induction with Equality Predicate Simplification (NI!)" . eq getRuleMsg(''le!.Qid) = "Lemma Enrichment with Equality Predicate Simplification (LE!)" . eq getRuleMsg(''sp!.Qid) = "Split with Equality Predicate Simplification (SP!)" . eq getRuleMsg(''cas!.Qid) = "Case with Equality Predicate Simplification (CAS!)" . eq getRuleMsg(''va!.Qid) = "Variable Abstraction with Equality Predicate Simplification (VA!)" . --- apply_to_. eq < prover : NuITP | ATS > parse(STR, 'apply_to_.['token[''eps.Qid],'token[GOAL]]) = checkGoal(< prover : NuITP | ATS >, STR, ''eps.Qid, 'apply_to_., GOAL, empty) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_.['token[''cvul.Qid],'token[GOAL]]) = checkGoal(< prover : NuITP | ATS >, STR, ''cvul.Qid, 'apply_to_., GOAL, empty) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_.['token[''cvufr.Qid],'token[GOAL]]) = checkGoal(< prover : NuITP | ATS >, STR, ''cvufr.Qid, 'apply_to_., GOAL, empty) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_.['token[''subl.Qid],'token[GOAL]]) = checkGoal(< prover : NuITP | ATS >, STR, ''subl.Qid, 'apply_to_., GOAL, empty) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_.['token[''subr.Qid],'token[GOAL]]) = checkGoal(< prover : NuITP | ATS >, STR, ''subr.Qid, 'apply_to_., GOAL, empty) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_.['token[''ns.Qid],'token[GOAL]]) = checkGoal(< prover : NuITP | ATS >, STR, ''ns.Qid, 'apply_to_., GOAL, empty) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_.['token[''cs.Qid],'token[GOAL]]) = checkGoal(< prover : NuITP | ATS >, STR, ''cs.Qid, 'apply_to_., GOAL, empty) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_.['token[''icc.Qid],'token[GOAL]]) = checkGoal(< prover : NuITP | ATS >, STR, ''icc.Qid, 'apply_to_., GOAL, empty) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_.['token[''varsat.Qid],'token[GOAL]]) = checkGoal(< prover : NuITP | ATS >, STR, ''varsat.Qid, 'apply_to_., GOAL, empty) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_.[NTL]) = < prover : NuITP | ATS > parse(STR, getTerm(noParse(1))) [ owise ] . --- apply_to_with_. eq < prover : NuITP | ATS > parse(STR, 'apply_to_with_.['token[''eq.Qid],'token[GOAL],'bubble[EQUALITY]]) = checkGoal(< prover : NuITP | ATS >, STR, ''eq.Qid, 'apply_to_with_., GOAL, EQUALITY) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_with_.['token[''eq!.Qid],'token[GOAL],'bubble[EQUALITY]]) = checkGoal(< prover : NuITP | ATS >, STR, ''eq!.Qid, 'apply_to_with_., GOAL, EQUALITY) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_with_.['token[''le.Qid],'token[GOAL],'bubble[LEMMA]]) = checkGoal(< prover : NuITP | ATS >, STR, ''le.Qid, 'apply_to_with_., GOAL, LEMMA) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_with_.['token[''le!.Qid],'token[GOAL],'bubble[LEMMA]]) = checkGoal(< prover : NuITP | ATS >, STR, ''le!.Qid, 'apply_to_with_., GOAL, LEMMA) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_with_.[NTL]) = < prover : NuITP | ATS > parse(STR, getTerm(noParse(1))) [ owise ] . --- apply_to_with_sub_. eq < prover : NuITP | ATS > parse(STR, 'apply_to_with_sub_.['token[''eq.Qid],'token[GOAL],'bubble[EQUALITY],'bubble[SUB]]) = checkGoal(< prover : NuITP | ATS >, STR, ''eq.Qid, 'apply_to_with_sub_., GOAL, (EQUALITY,SUB)) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_with_sub_.['token[''eq!.Qid],'token[GOAL],'bubble[EQUALITY],'bubble[SUB]]) = checkGoal(< prover : NuITP | ATS >, STR, ''eq!.Qid, 'apply_to_with_sub_., GOAL, (EQUALITY,SUB)) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_with_sub_.['token[''sp.Qid],'token[GOAL],'bubble[DISJ],'bubble[SUB]]) = checkGoal(< prover : NuITP | ATS >, STR, ''sp.Qid, 'apply_to_with_sub_., GOAL, (DISJ,SUB)) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_with_sub_.['token[''sp!.Qid],'token[GOAL],'bubble[DISJ],'bubble[SUB]]) = checkGoal(< prover : NuITP | ATS >, STR, ''sp!.Qid, 'apply_to_with_sub_., GOAL, (DISJ,SUB)) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_with_sub_.[NTL]) = < prover : NuITP | ATS > parse(STR, getTerm(noParse(1))) [ owise ]. --- apply_to_on_. eq < prover : NuITP | ATS > parse(STR, 'apply_to_on_.['token[''ni.Qid],'token[GOAL],'bubble[NAWEX]]) = checkGoal(< prover : NuITP | ATS >, STR, ''ni.Qid, 'apply_to_on_., GOAL, NAWEX) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_on_.['token[''ni!.Qid],'token[GOAL],'bubble[NAWEX]]) = checkGoal(< prover : NuITP | ATS >, STR, ''ni!.Qid, 'apply_to_on_., GOAL, NAWEX) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_on_.['token[''va.Qid],'token[GOAL],'bubble[TERM]]) = checkGoal(< prover : NuITP | ATS >, STR, ''va.Qid, 'apply_to_on_., GOAL, TERM) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_on_.['token[''va!.Qid],'token[GOAL],'bubble[TERM]]) = checkGoal(< prover : NuITP | ATS >, STR, ''va!.Qid, 'apply_to_on_., GOAL, TERM) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_on_.[NTL]) = < prover : NuITP | ATS > parse(STR, getTerm(noParse(1))) [ owise ] . --- apply_to_on_with_. eq < prover : NuITP | ATS > parse(STR, 'apply_to_on_with_.['token[''gsi.Qid],'token[GOAL],'bubble[VAR],'bubble[GENSET]]) = checkGoal(< prover : NuITP | ATS >, STR, ''gsi.Qid, 'apply_to_on_with_., GOAL, (VAR,GENSET)) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_on_with_.['token[''gsi!.Qid],'token[GOAL],'bubble[VAR],'bubble[GENSET]]) = checkGoal(< prover : NuITP | ATS >, STR, ''gsi!.Qid, 'apply_to_on_with_., GOAL, (VAR,GENSET)) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_on_with_.['token[''cas.Qid],'token[GOAL],'bubble[VAR],'bubble[GENSET]]) = checkGoal(< prover : NuITP | ATS >, STR, ''cas.Qid, 'apply_to_on_with_., GOAL, (VAR,GENSET)) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_on_with_.['token[''cas!.Qid],'token[GOAL],'bubble[VAR],'bubble[GENSET]]) = checkGoal(< prover : NuITP | ATS >, STR, ''cas!.Qid, 'apply_to_on_with_., GOAL, (VAR,GENSET)) . eq < prover : NuITP | ATS > parse(STR, 'apply_to_on_with_.[NTL]) = < prover : NuITP | ATS > parse(STR, getTerm(noParse(1))) [ owise ] . op checkGoal : Configuration String Qid Qid Term TermList -> Configuration . eq checkGoal(< prover : NuITP | ATS, proof: PROOF >, STR, RULE, CMD, GOAL, ARGS) = if isGoal(PROOF, getGID(GOAL)) then checkFrontier(< prover : NuITP | ATS, proof: PROOF >, STR, RULE, CMD, getGID(GOAL), ARGS) else error(< prover : NuITP | ATS, proof: PROOF >, "Goal " + getGID(GOAL) + " does not exist.", true) fi . op checkFrontier : Configuration String Qid Qid String TermList -> Configuration . eq checkFrontier(< prover : NuITP | ATS, proof: PROOF >, STR, RULE, CMD, GID, ARGS) = if isFrontier(PROOF, GID) then checkArgs(< prover : NuITP | ATS, proof: PROOF >, STR, RULE, CMD, GID, ARGS) else error(< prover : NuITP | ATS, proof: PROOF >, "Goal " + GID + " is not in the frontier.", true) fi . op checkArgs : Configuration String Qid Qid String TermList -> Configuration . eq checkArgs(CONF, STR, RULE, 'apply_to_., GID, empty) = checkApply(CONF, STR, RULE, GID, ('ID:String <- upTerm(GID))) . ceq checkArgs(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, 'apply_to_with_., GID, EQUALITY) = if PARSED-EQUALITY :: Term then checkApply(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, GID, ('ID:String <- upTerm(GID) ; 'ARG1:Term <- upTerm(PARSED-EQUALITY) ; 'ARG2:Substitution <- 'none.Substitution)) else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, "Equality not valid.", true) fi if (RULE == ''eq.Qid) or-else (RULE == ''eq!.Qid) /\ EXT-MODULE := addOps(extModule(MODNAME), getSkolemOps(PROOF, GID)) /\ PARSED-EQUALITY := parseEquality(EXT-MODULE, downTerm(EQUALITY, 'nil.QidList)) . ceq checkArgs(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, 'apply_to_with_sub_., GID, (EQUALITY,SUB)) = if PARSED-EQUALITY :: Term then if PARSED-SUB :: Substitution then checkApply(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, GID, ('ID:String <- upTerm(GID) ; 'ARG1:Term <- upTerm(PARSED-EQUALITY) ; 'ARG2:Substitution <- upTerm(PARSED-SUB))) else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, "Substitution not valid.", true) fi else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, "Equality not valid.", true) fi if (RULE == ''eq.Qid) or-else (RULE == ''eq!.Qid) /\ EXT-MODULE := addOps(extModule(MODNAME), getSkolemOps(PROOF, GID)) /\ PARSED-EQUALITY := parseEquality(EXT-MODULE, downTerm(EQUALITY, 'nil.QidList)) /\ PARSED-SUB := parseSubstitution(EXT-MODULE, downTerm(SUB, 'nil.QidList)) . ceq checkArgs(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, 'apply_to_with_., GID, LEMMA) = if PARSED-LEMMA :: Term then checkApply(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, GID, ('ID:String <- upTerm(GID) ; 'ARG1:Term <- upTerm(PARSED-LEMMA))) else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, "Lemma not valid.", true) fi if (RULE == ''le.Qid) or-else (RULE == ''le!.Qid) /\ EXT-MODULE := addOps(extModule(MODNAME), getSkolemOps(PROOF, GID)) /\ PARSED-LEMMA := parseClause(EXT-MODULE, downTerm(LEMMA, 'nil.QidList)) . ceq checkArgs(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, 'apply_to_with_sub_., GID, (DISJ,SUB)) = if PARSED-DISJ :: Term then if PARSED-SUB :: Substitution then checkApply(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, GID, ('ID:String <- upTerm(GID) ; 'ARG1:Term <- upTerm(PARSED-DISJ) ; 'ARG2:Substitution <- upTerm(PARSED-SUB))) else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, "Substitution not valid.", true) fi else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, "Disjunction not valid.", true) fi if (RULE == ''sp.Qid) or-else (RULE == ''sp!.Qid) /\ EXT-MODULE := addOps(extModule(MODNAME), getSkolemOps(PROOF, GID)) /\ PARSED-DISJ := parseDisjunction(EXT-MODULE, downTerm(DISJ, 'nil.QidList)) /\ PARSED-SUB := parseSubstitution(EXT-MODULE, downTerm(SUB, 'nil.QidList)) . ceq checkArgs(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, 'apply_to_on_., GID, NAWEX) = if PARSED-TERM :: Term then checkApply(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, GID, ('ID:String <- upTerm(GID) ; 'ARG1:Term <- upTerm(PARSED-TERM))) else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, "Narrowex not valid.", true) fi if (RULE == ''ni.Qid) or-else (RULE == ''ni!.Qid) /\ EXT-MODULE := addOps(extModule(MODNAME), getSkolemOps(PROOF, GID)) /\ PARSED-TERM := parseTerm(EXT-MODULE, downTerm(NAWEX, 'nil.QidList)) . ceq checkArgs(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, 'apply_to_on_., GID, TERM) = if PARSED-TERM :: Term then checkApply(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, GID, ('ID:String <- upTerm(GID) ; 'ARG1:Term <- upTerm(PARSED-TERM))) else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, "Term not valid.", true) fi if (RULE == ''va.Qid) or-else (RULE == ''va!.Qid) /\ EXT-MODULE := addOps(extModule(MODNAME), getSkolemOps(PROOF, GID)) /\ PARSED-TERM := parseTerm(EXT-MODULE, downTerm(TERM, 'nil.QidList)) . ceq checkArgs(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, 'apply_to_on_with_., GID, (VAR,GENSET)) = if (PARSED-VAR :: Variable) then if (PARSED-VAR in getClause(PROOF, GID)) then if (PARSED-GENSET :: TermSet) and-then (getVars(PARSED-GENSET) notIn getVars(getClause(PROOF, GID))) then checkApply(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, GID, ('ID:String <- upTerm(GID) ; 'ARG1:Variable <- upTerm(PARSED-VAR) ; 'ARG2:TermSet <- upTerm(PARSED-GENSET))) else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, "Generator set not valid.", true) fi else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, "Variable not found in the clause.", true) fi else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, "Variable not valid.", true) fi if (RULE == ''gsi.Qid) or-else (RULE == ''gsi!.Qid) /\ EXT-MODULE := addOps(extModule(MODNAME), getSkolemOps(PROOF, GID)) /\ PARSED-VAR := parseTerm(EXT-MODULE, downTerm(VAR, 'nil.QidList)) /\ PARSED-GENSET := parseGenSet(EXT-MODULE, leastSort(EXT-MODULE, PARSED-VAR), downTerm(GENSET,'nil.QidList)) . ceq checkArgs(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, 'apply_to_on_with_., GID, (VAR,GENSET)) = if (PARSED-VAR :: Variable) then if PARSED-VAR in getClause(PROOF, GID) then if (PARSED-GENSET :: TermSet) and-then (getVars(PARSED-GENSET) notIn getVars(getClause(PROOF, GID))) then checkApply(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, GID, ('ID:String <- upTerm(GID) ; 'ARG1:Variable <- VAR ; 'ARG2:TermSet <- upTerm(PARSED-GENSET))) else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, "Generator set not valid.", true) fi else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, "Variable not found in the clause.", true) fi else if PARSED-VAR :: Constant then if PARSED-VAR in getClause(PROOF, GID) then if (PARSED-GENSET :: TermSet) and-then (getVars(PARSED-GENSET) notIn getVars(getClause(PROOF, GID))) then checkApply(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, STR, RULE, GID, ('ID:String <- upTerm(GID) ; 'ARG1:Constant <- upTerm(PARSED-VAR) ; 'ARG2:TermSet <- upTerm(PARSED-GENSET))) else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, "Generator set not valid.", true) fi else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, "Skolem variable not found in the clause.", true) fi else error(< prover : NuITP | ATS, module: MODNAME, proof: PROOF >, "Variable not valid.", true) fi fi if (RULE == ''cas.Qid) or-else (RULE == ''cas!.Qid) /\ EXT-MODULE := addOps(extModule(MODNAME), getSkolemOps(PROOF, GID)) /\ PARSED-VAR := parseTerm(EXT-MODULE, downTerm(VAR, 'nil.QidList)) /\ PARSED-GENSET := parseGenSet(EXT-MODULE, leastSort(EXT-MODULE, PARSED-VAR), downTerm(GENSET,'nil.QidList)) . op checkApply : Configuration String Qid String Substitution -> Configuration . eq checkApply(< prover : NuITP | ATS, proof: PROOF, mode: MODE >, STR, RULE, GID, SB) = if metaApply(upModule('NuITP-INDUCTION-RULES, false), PROOF, downTerm(RULE, 'nil.QidList), SB, 0) == (failure).ResultTriple? then error(< prover : NuITP | ATS, proof: PROOF, mode: MODE >, "Failure applying rule " + string(downTerm(RULE,'nil.QidList)) + " to goal " + GID + ".", true) else < prover : NuITP | ATS, proof: addLog(getTerm(metaApply(upModule('NuITP-INDUCTION-RULES,false), PROOF, downTerm(RULE,'nil.QidList), SB, 0)), STR), mode: MODE > write(stdout, prover, (if (MODE == user) then "\n" else "" fi) + CYAN + " " + getRuleMsg(RULE) + " applied to goal " + GID + "." + BW + "\n\n" + toStringApply( getModule(PROOF), getFrontier(getTerm(metaApply(upModule('NuITP-INDUCTION-RULES, false), PROOF, downTerm(RULE, 'nil.QidList), SB, 0))), getChildren(getTerm(metaApply(upModule('NuITP-INDUCTION-RULES, false), PROOF, downTerm(RULE, 'nil.QidList), SB, 0)), GID) ) ) fi . endm erew in NuITP : init . eof --- General commands --- q --- Example: q (NOTE: Short version of quit) quit --- Example: quit help --- Example: help --- I/O operations (NOTE: Maude needs to be initialized with the -trust flag) load FILENAME --- Example: load scripts/ex3 save FILENAME --- Example: save myProof export FILENAME --- Example: export myProof (will create a myProof.tex file) --- Info commands --- show log . --- Example: show log show module . --- Example: show module show goal GID . --- Example: show goal 0 show goals . --- Example: show goals show frontier . --- Example: show frontier --- Init commands --- set module MODNAME . --- Example: set module TEST-EX3 . set goal GOAL . --- Example: set goal { X:Nat ^ s(s(0)) , Y:Nat } = { s(Y:Nat), 0 } -> [ X:Nat + X:Nat ^ s(s(0)) , (X:Nat * X:Nat) ] = [ s(X:Nat + Y:Nat), X:Nat ] . set goal GOAL skolem TERMSET . --- Example: set goal { X:Nat ^ s(s(0)) , Y:Nat } = { s(Y:Nat), 0 } -> [ X:Nat + X:Nat ^ s(s(0)) , (X:Nat * X:Nat) ] = [ s(X:Nat + Y:Nat), X ] skolem X:Nat . --- Simplification commands --- apply eps to GID . --- Example: apply eps to 0 . apply cvul to GID . --- Example: apply cvul to 0 . apply cvufr to GID . --- Example: apply cvufr to 0 . apply subl to GID . --- Example: apply subl to 0 . apply subr to GID . --- Example: apply subr to 0 . apply ns to GID . --- Example: apply ns to 0 . apply cs to GID . --- Example: apply cs to 0 . apply icc to GID . --- Example: apply icc to 0 . apply varsat to GID . --- Example: apply varsat to 0 . apply eq to GID with EQUALITY . --- Example: apply eq to 0.1 with X:Nat + Y:Nat => Y:Nat + X:Nat . --- Induction commands --- apply gsi to GID on VAR with GENSET . --- Example: apply gsi to 0 on X:Nat with 0 ;; (1 + X1:Nat) . apply ni to GID on SUBTERM . --- Example: apply ni to 0 on rev(Q:List Y:Elt) . apply le to GID with LEMMA . --- Example: apply le to 0 with X:Nat * Z':NzNat = Y:Nat * Z':NzNat -> X:Nat = Y:Nat . apply sp to GID with DISJ sub SUB . --- Example: apply sp to 0 with Y:Nat = 0 \/ Y:Nat = s(0) sub none . apply cas to GID on VAR with GENSET . --- Example: apply cas to 0.1.1 on X:Nat with 0 ;; s(0) ;; s(s(Y:Nat)) . apply va to GID on SUBTERM . --- Example: apply va to 0.1.2 on Y':Nat * Z':NzNat . --- Induction + Simplification commands --- apply gsi! to GID on VAR with GENSET . --- Example: apply gsi! to 0 on X:Nat with 0 ;; (1 + X1:Nat) . apply ni! to GID on SUBTERM . --- Example: apply ni! to 0 on rev(Q:List Y:Elt) . apply le! to GID with LEMMA . --- Example: apply le! to 0 with X:Nat * Z':NzNat = Y:Nat * Z':NzNat -> X:Nat = Y:Nat . apply sp! to GID on DISJ with SUB . --- Example: apply sp! to 0 on Y:Nat = 0 \/ Y:Nat = s(0) with none . apply cas! to GID on VAR with GENSET . --- Example: apply cas! to 0.1.1 on X:Nat with 0 ;; s(0) ;; s(s(Y:Nat)) . apply va! to GID on SUBTERM . --- Example: apply va! to 0.1.2 on Y':Nat * Z':NzNat . --- Undo command --- undo GID . --- Example: undo 0.1 .