From b371e3e256dd693fa5588bc2dbe778c0b438de3c Mon Sep 17 00:00:00 2001 From: Andrea <80176994+agilot@users.noreply.github.com> Date: Thu, 18 Apr 2024 22:42:22 +0200 Subject: [PATCH] Type checking and ADTs (#219) Implements basis of a type system with type checking, ADTs. induction and more. Co-authored-by: SimonGuilloud Co-authored-by: Simon Guilloud Co-authored-by: Sankalp Gambhir --- .gitignore | 2 + CHANGES.md | 4 + build.sbt | 5 +- lisa-examples/src/main/scala/ADTExample.scala | 125 ++ lisa-sets/src/main/scala/lisa/Main.scala | 3 + .../main/scala/lisa/automation/Apply.scala | 262 +-- .../scala/lisa/automation/CommonTactics.scala | 2 +- .../scala/lisa/automation/atp/Goeland.scala | 18 +- .../maths/settheory/types/TypeSystem.scala | 535 +++++ .../maths/settheory/types/adt/Frontend.scala | 566 ++++++ .../maths/settheory/types/adt/Functions.scala | 134 ++ .../maths/settheory/types/adt/Helpers.scala | 1030 ++++++++++ .../maths/settheory/types/adt/Tactics.scala | 174 ++ .../maths/settheory/types/adt/Typed.scala | 285 +++ .../maths/settheory/types/adt/Untyped.scala | 1752 +++++++++++++++++ .../maths/settheory/types/adt/package.scala | 200 ++ .../src/main/scala/lisa/fol/Common.scala | 145 +- .../src/main/scala/lisa/fol/FOLHelpers.scala | 2 + .../src/main/scala/lisa/fol/Lambdas.scala | 2 +- .../src/main/scala/lisa/fol/Sequents.scala | 8 +- .../main/scala/lisa/prooflib/BasicMain.scala | 1 + .../scala/lisa/prooflib/BasicStepTactic.scala | 7 +- .../main/scala/lisa/prooflib/Library.scala | 5 + .../scala/lisa/prooflib/ProofsHelpers.scala | 34 +- .../lisa/prooflib/SimpleDeducedSteps.scala | 28 +- .../scala/lisa/prooflib/WithTheorems.scala | 3 +- .../main/scala/lisa/utils/KernelHelpers.scala | 2 +- .../lisa/utils/memoization/Memoized.scala | 37 + .../lisa/kernel/TheoriesHelpersTest.scala | 3 +- refman/lisa.pdf | Bin 248723 -> 251598 bytes 30 files changed, 5199 insertions(+), 175 deletions(-) create mode 100644 lisa-examples/src/main/scala/ADTExample.scala create mode 100644 lisa-sets/src/main/scala/lisa/maths/settheory/types/TypeSystem.scala create mode 100644 lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Frontend.scala create mode 100644 lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Functions.scala create mode 100644 lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Helpers.scala create mode 100644 lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Tactics.scala create mode 100644 lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Typed.scala create mode 100644 lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Untyped.scala create mode 100644 lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/package.scala create mode 100644 lisa-utils/src/main/scala/lisa/utils/memoization/Memoized.scala diff --git a/.gitignore b/.gitignore index b05d0969a..aaadedc95 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,8 @@ .metals .vscode project/metals.sbt +project/project/metals.sbt +sbt-launch.jar # build-related .bsp diff --git a/CHANGES.md b/CHANGES.md index c8dd41a37..9e00084ae 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -1,5 +1,9 @@ # Change List +## 2024-04-12 +Addition of simply typed lambda calculus with top level polymorphism and inductive poylmorphic algebraic data types. +Addition of tactics for typechecking and structural induction over ADTs. + ## 2024-03-02 Support for reconstructing proofs from file in SC-TPTP format. Support and inclusion of Goeland as a tactic. Doc in the manual. diff --git a/build.sbt b/build.sbt index 1e5841104..bc9c0c1be 100644 --- a/build.sbt +++ b/build.sbt @@ -20,7 +20,7 @@ ThisBuild / scalafixDependencies += "com.github.liancheng" %% "organize-imports" val commonSettings = Seq( - crossScalaVersions := Seq("2.12.13", "2.13.4", "3.0.1", "3.2.0"), + crossScalaVersions := Seq("3.3.1"), run / fork := true ) @@ -40,10 +40,11 @@ val commonSettings3 = commonSettings ++ Seq( // "-source:future", re-enable when liancheng/scalafix-organize-imports#221 is fixed ), + javaOptions += "-Xmx10G", libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.10" % "test", libraryDependencies += "com.lihaoyi" %% "sourcecode" % "0.3.0", //libraryDependencies += "org.scala-lang.modules" %% "scala-parser-combinators" % "2.1.1", - libraryDependencies += ("io.github.uuverifiers" %% "princess" % "2023-06-19").cross(CrossVersion.for3Use2_13), + // libraryDependencies += ("io.github.uuverifiers" %% "princess" % "2023-06-19").cross(CrossVersion.for3Use2_13), Test / parallelExecution := false ) diff --git a/lisa-examples/src/main/scala/ADTExample.scala b/lisa-examples/src/main/scala/ADTExample.scala new file mode 100644 index 000000000..8314d18c6 --- /dev/null +++ b/lisa-examples/src/main/scala/ADTExample.scala @@ -0,0 +1,125 @@ +object ADTExample extends lisa.Main { + import lisa.maths.settheory.types.adt.{*, given} + + // variable declarations + val A = variable + + val n = variable + val l = variable + val x = variable + val y = variable + + val x0 = variable + val x1 = variable + val y0 = variable + val y1 = variable + + // *********************** + // * 1 : Examples of ADT * + // *********************** + + // Boolean + val define(bool: ADT[0], constructors(tru, fals)) = () | () + + // Nat + val define(nat: ADT[0], constructors(zero, succ)) = () | nat + + // Option + val define(option: ADT[1], constructors(none, some)) = A --> () | A + + // List + val define(list: ADT[1], constructors(nil, cons)) = A --> () | (A, list) + + // Nothing + val define(nothing, constructors()) = | + + // **************** + // * 2 : Theorems * + // **************** + + // Injectivity + show(nil.injectivity) + show(cons.injectivity) + show(list.injectivity(nil, cons)) + + // Introduction rules + show(nil.intro) + show(cons.intro) + + Lemma(nil(A) :: list(A)){ + have(thesis) by TypeChecker.prove + } + Lemma((x :: A, l :: list(A)) |- cons(A) * x * l :: list(A)){ + have(thesis) by TypeChecker.prove + } + + // Induction + show(list.induction) + + // Pattern matching + show(list.elim) + + // ***************** + // * 3 : Functions * + // ***************** + + val not = fun(bool, bool) { + Case(tru) { fals } + Case(fals) { tru } + } + + val pred = fun(nat, nat): + Case(zero): + zero + Case(succ, n): + n + + + // ************************ + // * 4 : Induction Tactic * + // ************************ + + Theorem(x :: bool |- not * (not * x) === x) { + have(thesis) by Induction() { + Case(tru) subproof { + val notFals = have(not * fals === tru) by Restate.from((not.elim(fals))) + have(fals === not * tru) by Restate.from(not.elim(tru)) + have(not * (not * tru) === tru) by Substitution.ApplyRules(lastStep)(notFals) + } + Case(fals) subproof { + val notTrue = have(not * tru === fals) by Restate.from((not.elim(tru))) + have(tru === not * fals) by Restate.from(not.elim(fals)) + have(not * (not * fals) === fals) by Substitution.ApplyRules(lastStep)(notTrue) + } + } + } + + // **************************** + // * 5: All features together * + // **************************** + + val consInj = Theorem((l :: list(A), x :: A) |- !(l === cons(A) * x * l)) { + + val typeNil = have(nil(A) :: list(A)) by TypeChecker.prove + val typeCons = have((y :: A, l :: list(A)) |- cons(A) * y * l :: list(A)) by TypeChecker.prove + + have(l :: list(A) |- forall(x, x :: A ==> !(l === cons(A) * x * l))) by Induction(){ + Case(nil) subproof { + have(x :: A ==> !(nil(A) === cons(A) * x * nil(A))) by Tautology.from(list.injectivity(nil, cons) of (y0 := x, y1 := nil(A)), typeNil) + thenHave(forall(x, x :: A ==> !(nil(A) === cons(A) * x * nil(A)))) by RightForall + } + Case(cons, y, l) subproof { + have((y :: A ==> !(l === cons(A) * y * l), y :: A, l :: list(A)) |- x :: A ==> !(cons(A) * y * l === cons(A) * x * (cons(A) * y * l))) by Tautology.from( + cons.injectivity of (x0 := y, x1 := l, y0 := x, y1 := cons(A) * y * l), + typeCons + ) + thenHave((y :: A ==> !(l === cons(A) * y * l), y :: A, l :: list(A)) |- forall(x, x :: A ==> !(cons(A) * y * l === cons(A) * x * (cons(A) * y * l)))) by RightForall + thenHave((forall(x, x :: A ==> !(l === cons(A) * x * l)), y :: A, l :: list(A)) |- forall(x, x :: A ==> !(cons(A) * y * l === cons(A) * x * (cons(A) * y * l)))) by LeftForall + } + } + + thenHave(l :: list(A) |- x :: A ==> !(l === cons(A) * x * l)) by InstantiateForall(x) + thenHave(thesis) by Tautology + } + +} \ No newline at end of file diff --git a/lisa-sets/src/main/scala/lisa/Main.scala b/lisa-sets/src/main/scala/lisa/Main.scala index 2ce01a39e..c96ac042b 100644 --- a/lisa-sets/src/main/scala/lisa/Main.scala +++ b/lisa-sets/src/main/scala/lisa/Main.scala @@ -29,6 +29,9 @@ trait Main extends BasicMain { def definition: JUSTIFICATION = { getDefinition(symbol).get } + def shortDefinition: JUSTIFICATION = { + getShortDefinition(symbol).get + } } } diff --git a/lisa-sets/src/main/scala/lisa/automation/Apply.scala b/lisa-sets/src/main/scala/lisa/automation/Apply.scala index 22b0bc9c1..a0c22d790 100644 --- a/lisa-sets/src/main/scala/lisa/automation/Apply.scala +++ b/lisa-sets/src/main/scala/lisa/automation/Apply.scala @@ -6,7 +6,10 @@ import lisa.prooflib.ProofTacticLib.* import lisa.prooflib.SimpleDeducedSteps.* import lisa.prooflib.* import lisa.utils.unification.UnificationUtils.* -import scala.util.boundary, boundary.break + +import scala.util.boundary + +import boundary.break /** @@ -48,16 +51,21 @@ class Apply(using val lib: Library, val proof: lib.Proof)(thm: proof.Fact) exten */ private def normalForm(seq: Sequent): Sequent = def removeImplies(s: Sequent): Sequent = - s.right.head match - case AppliedConnector(Implies, Seq(phi, psi)) => s.left + phi |- psi - case _ => s - + if s.right.isEmpty then + s + else + s.right.head match + case AppliedConnector(Implies, Seq(phi, psi)) => removeImplies(s.left + phi |- psi) + case _ => s + + + def removeConjunctions(s: Sequent): Sequent = - s.left.flatMap(f => - f match - case AppliedConnector(And, Seq(phi, psi)) => Set(phi, psi) - case _ => Set(f) - ) |- s.right + def rec(f: Formula): Set[Formula] = + f match + case AppliedConnector(And, Seq(phi, psi)) => rec(phi) ++ rec(psi) + case _ => Set(f) + s.left.flatMap(rec) |- s.right removeConjunctions(removeImplies(seq)) @@ -106,128 +114,140 @@ class Apply(using val lib: Library, val proof: lib.Proof)(thm: proof.Fact) exten private def substitute(using _proof: lib.Proof)(fact: _proof.Fact, fSubst: FormulaSubstitution, tSubst: TermSubstitution): _proof.Fact = fact.of(fSubst.toFSubstPair: _*).of(tSubst.toTSubstPair: _*) - /** - * Applies on method with a sequence as an argument instead of a varargs. - */ - infix def onSeq(premises: Seq[proof.Fact])(bot: Sequent): proof.ProofTacticJudgement = on(premises : _*)(bot) + * Applies on method with a varargs instead of a sequence. + */ + infix def on(premises: proof.Fact*)(bot: Sequent): proof.ProofTacticJudgement = on(premises.toSeq)(bot) + /** * Executes the tactic. See class description for use cases. * * @param premises the facts that are applied to the theorem + * @param excluding the variables that are not to be substituted * @param bot the sequent the user want to prove */ - infix def on(premises: proof.Fact*)(bot: Sequent): proof.ProofTacticJudgement = - - boundary: - TacticSubproof { sp ?=> - - // STEP 1: Convert the given theorem, facts and sequent to their normal forms - val botNormalized: Sequent = normalForm(bot) - val thmNormalized: sp.Fact = lib.have(normalForm(thm.statement)) by Restate.from(thm) - val premisesNormalized = premises.map(p => lib.have(normalForm(p.statement)) by Restate.from(p)) - - // STEP 2: Unify the conclusion of the sequent the user want to prove and the conclusion - val botCcl: Formula = botNormalized.right.head - val thmCcl: Formula = thmNormalized.statement.right.head - - matchFormula(botCcl, thmCcl) match - case Some((formulaCclAssignment, termCclAssignment)) => - - //Unification succeeded, subtitution can be performed - val thmAfterCclUnification: sp.Fact = substitute(thmNormalized, formulaCclAssignment, termCclAssignment) - - // STEP 3: Process each fact - val thmAfterPrems: sp.Fact = { - - premisesNormalized.foldLeft(lib.have(thmAfterCclUnification))((updatedThm, premNormalized) => { - - - val premCcl: Formula = premNormalized.statement.right.head - - // STEP 3.1: Unify the conclusion of the fact with a premise of the theorem - // Three possibilities: - // - the unification succeeded and the variables in the theorem are subtituted to match the conclusion of the fact; - // - if the unification did not succeeded, try the unification in the other direction, i.e. try to specify the fact - // instead of the theorem. If this works, make the susbtitution inside the fact; - // - both unifications do not succeed and the fact is dropped. - // TODO: add a warning when the fact is dropped - val conclusionsUnification: Option[(sp.Fact, sp.Fact)] = - searchPremises(updatedThm.statement, premCcl) match - case Some((fSubstAfterPrem, tSubstAfterPrem)) => Some((substitute(updatedThm, fSubstAfterPrem, tSubstAfterPrem), premNormalized)) - case None => - searchPremisesRev(updatedThm.statement, premCcl) match - case Some((fSubstAfterPrem, tSubstAfterPrem)) => Some((updatedThm, substitute(premNormalized, fSubstAfterPrem, tSubstAfterPrem))) - case None => None - - - - - conclusionsUnification match - case Some(updatedThmAfterCclUnification, premAfterCclUnification) => - - // STEP 3.2: For each premise of the fact: - // - check if it is in the sequent the user want to prove. If yes, add it to the preconditions of the theorem - // using weakening; - // - else if it matches one of the premises of the theorem specify the theorem by using the appropriate sustitution. - // When performing this operation, the conclusion of the fact must be temporarily removed from the premises of the theorem - // to avoid buggy situations in case the fact is of the form p |- p; - // - else add the premise to the premises of the theorem using weakening. - val premCclAfterCclUnification: Formula = premAfterCclUnification.statement.right.head - - val updatedThmAfterWeakening: sp.Fact = - premAfterCclUnification.statement.left.foldLeft(updatedThmAfterCclUnification)((updatedThmDuringWeakening, premPrem) => { - if botNormalized.left.contains(premPrem) then - lib.have(updatedThmDuringWeakening.statement +<< premPrem) by Weakening(updatedThmDuringWeakening) - else - searchPremises(updatedThmDuringWeakening.statement - - substitute(updatedThmDuringWeakening, fSubstDuringWeakening, tSubstDuringWeakening) - case None => - lib.have(updatedThmDuringWeakening.statement +<< premPrem) by Weakening(updatedThmDuringWeakening) - }) - - - // STEP 3.3 Use cut to apply the conclusion of the fact to the theorem - // TODO: maybe throw a warning when the fact cannot be applied instead of making the proof crash - val cutStep: sp.ProofTacticJudgement = Cut(premAfterCclUnification, updatedThmAfterWeakening)(updatedThmAfterWeakening.statement - updatedThm - - }) - } - - // STEP 4: If some cases, after all these operations, the theorem can remain too general to prove the sequent. - // To avoid such situation, perform a last unification between the premises of the sequent and those - // of the theorem. - val thmAfterLastUnification: sp.Fact = botNormalized.left.foldLeft(thmAfterPrems)((updatedThm, premBot) => { - searchPremises(updatedThm.statement, premBot) match - case Some(fSubst, tSubst) => substitute(updatedThm, fSubst, tSubst) + infix def on(premises: Seq[proof.Fact], excluding: Iterable[Variable | VariableFormula] = Set())(bot: Sequent): proof.ProofTacticJudgement = + + if thm == null then + proof.InvalidProofTactic("The theorem is null. Please check that it has been defined earlier in the proof.") + else if premises.exists(_ == null) then + proof.InvalidProofTactic("One of the premises is null. Please check that they all have been defined earlier in the proof.") + else + // STEP 0: Separate the variables and the variable formula in their respective sets + val (excludingTVars, excludingFVars) = excluding.foldLeft[(Set[Variable], Set[VariableFormula])](Set(), Set())((acc, v) => v match + case v: Variable => (acc._1 + v, acc._2) + case v: VariableFormula => (acc._1, acc._2 + v) + ) + + boundary{ + TacticSubproof { sp ?=> + + // STEP 1: Convert the given theorem, facts and sequent to their normal forms + val botNormalized: Sequent = normalForm(bot) + val thmNormalized: sp.Fact = lib.have(normalForm(thm.statement)) by Restate.from(thm) + val premisesNormalized = premises.map(p => lib.have(normalForm(p.statement)) by Restate.from(p)) + + // STEP 2: Unify the conclusion of the sequent the user want to prove and the conclusion + val thmAfterCclUnification: sp.Fact = + (botNormalized.right.isEmpty, thmNormalized.statement.right.isEmpty) match + case (true, true) => thmNormalized + case (true, false) => break(proof.InvalidProofTactic(s"The given theorem could not prove the sequent.")) + case (false, true) => break(proof.InvalidProofTactic(s"The given theorem could not prove the sequent.")) + case (false, false) => + val botCcl: Formula = botNormalized.right.head + val thmCcl: Formula = thmNormalized.statement.right.head + + matchFormula(botCcl, thmCcl, excludingTVars, excludingFVars) match + //Unification succeeded, subtitution can be performed + case Some((formulaCclAssignment, termCclAssignment)) => substitute(thmNormalized, formulaCclAssignment, termCclAssignment) + // STEP 2 failed + case None => break(proof.InvalidProofTactic(s"The conclusion of the goal and the theorem could not be unified.")) + + // STEP 3: Process each fact + val thmAfterPrems: sp.Fact = { + + premisesNormalized.foldLeft(lib.have(thmAfterCclUnification))((updatedThm, premNormalized) => { + + + val premCcl: Formula = premNormalized.statement.right.head + + // STEP 3.1: Unify the conclusion of the fact with a premise of the theorem + // Three possibilities: + // - the unification succeeded and the variables in the theorem are subtituted to match the conclusion of the fact; + // - if the unification did not succeeded, try the unification in the other direction, i.e. try to specify the fact + // instead of the theorem. If this works, make the susbtitution inside the fact; + // - both unifications do not succeed and the fact is dropped. + // TODO: add a warning when the fact is dropped + val conclusionsUnification: Option[(sp.Fact, sp.Fact)] = + searchPremises(updatedThm.statement, premCcl, excludingTVars, excludingFVars) match + case Some((fSubstAfterPrem, tSubstAfterPrem)) => Some((substitute(updatedThm, fSubstAfterPrem, tSubstAfterPrem), premNormalized)) + case None => + searchPremisesRev(updatedThm.statement, premCcl, excludingTVars, excludingFVars) match + case Some((fSubstAfterPrem, tSubstAfterPrem)) => Some((updatedThm, substitute(premNormalized, fSubstAfterPrem, tSubstAfterPrem))) + case None => None + + conclusionsUnification match + case Some(updatedThmAfterCclUnification, premAfterCclUnification) => + + // STEP 3.2: For each premise of the fact: + // - check if it is in the sequent the user want to prove. If yes, add it to the preconditions of the theorem + // using weakening; + // - else if it matches one of the premises of the theorem specify the theorem by using the appropriate sustitution. + // When performing this operation, the conclusion of the fact must be temporarily removed from the premises of the theorem + // to avoid buggy situations in case the fact is of the form p |- p; + // - else add the premise to the premises of the theorem using weakening. + val premCclAfterCclUnification: Formula = premAfterCclUnification.statement.right.head + + val updatedThmAfterWeakening: sp.Fact = + premAfterCclUnification.statement.left.foldLeft(updatedThmAfterCclUnification)((updatedThmDuringWeakening, premPrem) => { + if botNormalized.left.contains(premPrem) then + lib.have(updatedThmDuringWeakening.statement +<< premPrem) by Weakening(updatedThmDuringWeakening) + else + searchPremises(updatedThmDuringWeakening.statement - + substitute(updatedThmDuringWeakening, fSubstDuringWeakening, tSubstDuringWeakening) + case None => + lib.have(updatedThmDuringWeakening.statement +<< premPrem) by Weakening(updatedThmDuringWeakening) + }) + + + // STEP 3.3 Use cut to apply the conclusion of the fact to the theorem + // TODO: maybe throw a warning when the fact cannot be applied instead of making the proof crash + val cutStep: sp.ProofTacticJudgement = Cut(premAfterCclUnification, updatedThmAfterWeakening)(updatedThmAfterWeakening.statement - updatedThm + }) - - // STEP 5: Prove the sequent using the theorem obtained with the previous steps. Weakening is necessary in case - // additional preconditions that do not appear in the theorem are present in the sequent. - val finalStep: sp.ProofTacticJudgement = Weakening(thmAfterLastUnification)(bot) - if finalStep.isValid then - lib.have(finalStep) - else - break(proof.InvalidProofTactic(s"The given theorem could not prove the sequent\n. Deduced theorem: ${thmAfterLastUnification.statement}")) - - // STEP 2 failed - case None => break(proof.InvalidProofTactic(s"The conclusion of the goal and the theorem could not be unified.")) - + } + + // STEP 4: If some cases, after all these operations, the theorem can remain too general to prove the sequent. + // To avoid such situation, perform a last unification between the premises of the sequent and those + // of the theorem. + val thmAfterLastUnification: sp.Fact = botNormalized.left.foldLeft(thmAfterPrems)((updatedThm, premBot) => { + searchPremises(updatedThm.statement, premBot, excludingTVars, excludingFVars) match + case Some(fSubst, tSubst) => substitute(updatedThm, fSubst, tSubst) + case None => updatedThm + }) + + // STEP 5: Prove the sequent using the theorem obtained with the previous steps. Weakening is necessary in case + // additional preconditions that do not appear in the theorem are present in the sequent. + val finalStep: sp.ProofTacticJudgement = Weakening(thmAfterLastUnification)(bot) + if finalStep.isValid then + lib.have(finalStep) + else + break(proof.InvalidProofTactic(s"The given theorem could not prove the sequent.\n Deduced theorem: ${thmAfterLastUnification.statement}\n Expected: ${bot}")) + + + } } - } /** diff --git a/lisa-sets/src/main/scala/lisa/automation/CommonTactics.scala b/lisa-sets/src/main/scala/lisa/automation/CommonTactics.scala index 9430195a1..c5b8e80a2 100644 --- a/lisa-sets/src/main/scala/lisa/automation/CommonTactics.scala +++ b/lisa-sets/src/main/scala/lisa/automation/CommonTactics.scala @@ -113,7 +113,7 @@ object CommonTactics { case F.AppliedPredicate(F.`equality`, Seq(`x`, (y: F.Variable))) if x != y && F.contains(uniquenessSeq.left, phi.substitute(x := y)) => y - case F.AppliedPredicate(F.`equality`, List(F.AppliedFunction(y: F.Variable, _), F.AppliedFunction(`x`, _))) if x != y && F.contains(uniquenessSeq.left, phi.substitute(x := y)) => + case F.AppliedPredicate(F.`equality`, List(F.AppliedFunctional(y: F.Variable, _), F.AppliedFunctional(`x`, _))) if x != y && F.contains(uniquenessSeq.left, phi.substitute(x := y)) => y } match { case Some(y) => ExistenceAndUniqueness.withParameters(phi, x, y)(existence, uniqueness)(bot) diff --git a/lisa-sets/src/main/scala/lisa/automation/atp/Goeland.scala b/lisa-sets/src/main/scala/lisa/automation/atp/Goeland.scala index 568110cd0..e8d50cf0b 100644 --- a/lisa-sets/src/main/scala/lisa/automation/atp/Goeland.scala +++ b/lisa-sets/src/main/scala/lisa/automation/atp/Goeland.scala @@ -1,18 +1,20 @@ package lisa.automation.atp -import lisa.utils.tptp.* -import ProofParser.* -import KernelParser.* - -import lisa.prooflib.ProofTacticLib.* import lisa.fol.FOL as F import lisa.prooflib.Library +import lisa.prooflib.OutputManager +import lisa.prooflib.ProofTacticLib.* import lisa.utils.K +import lisa.utils.tptp.* import java.io.* -import sys.process._ import scala.io.Source -import scala.util.{Try, Success, Failure} -import lisa.prooflib.OutputManager +import scala.util.Failure +import scala.util.Success +import scala.util.Try + +import ProofParser.* +import KernelParser.* +import sys.process._ /** * Goéland is an automated theorem prover. This tactic calls the Goéland prover to solve the current sequent. diff --git a/lisa-sets/src/main/scala/lisa/maths/settheory/types/TypeSystem.scala b/lisa-sets/src/main/scala/lisa/maths/settheory/types/TypeSystem.scala new file mode 100644 index 000000000..850103caa --- /dev/null +++ b/lisa-sets/src/main/scala/lisa/maths/settheory/types/TypeSystem.scala @@ -0,0 +1,535 @@ +package lisa.maths.settheory.types + +import lisa.prooflib.ProofTacticLib.* +import lisa.fol.FOL +import lisa.automation.Tautology +import lisa.fol.FOL.{*, given} +import lisa.prooflib.BasicStepTactic.* +import lisa.prooflib.SimpleDeducedSteps.* +import lisa.SetTheoryLibrary.{given, *} +import lisa.SetTheoryLibrary +import lisa.kernel.proof.SequentCalculus.SCProofStep +import lisa.maths.settheory.SetTheory.functional +import lisa.prooflib.OutputManager +import lisa.maths.settheory.SetTheory.{singleton, app} + +object TypeLib extends lisa.Main { + + import TypeSystem.* + + val |=> : ConstantFunctionLabel[2] = ConstantFunctionLabel.infix("|=>", 2) + private inline def temp = |=> + extension (t:Term) { + def |=>(o:Term): Term = TypeLib.temp(t, o) + } + val app: ConstantFunctionLabel[2] = lisa.maths.settheory.SetTheory.app + addSymbol(|=>) + + val f = variable + val x = variable + val y = variable + val z = variable + val A = variable + val B = variable + val F = function[1] + val funcspaceAxiom = Axiom(f ∈ (A |=> B) ==> (x ∈ A ==> app(f, x) ∈ B)) + val any = DEF(x) --> top + + + // A |=> B is the set of functions from A to B + // C |> D is the functional class of functionals from the class C to the class D + // F is C |> D desugars into ∀(x, (x is C) => (F(x) is D)) + + val testTheorem = Theorem((x is A, f is (A |=> B), F is (A |=> B) |> (A |=> B) ) |- (F(f)*(x) is B)) { + have(thesis) by TypeChecker.prove + } + + val 𝔹 = DEF() --> unorderedPair(∅, singleton(∅)) + + val empty_in_B = Theorem( (∅ :: 𝔹) ) { + have( ∅ :: unorderedPair(∅, singleton(∅))) by Tautology.from(pairAxiom of (z := ∅, x := ∅, y := singleton(∅))) + thenHave(thesis ) by Substitution.ApplyRules(𝔹.shortDefinition) + } + + val sing_empty_in_B = Theorem( (singleton(∅) :: 𝔹) ) { + have( singleton(∅) :: unorderedPair(∅, singleton(∅))) by Tautology.from(pairAxiom of (z := singleton(∅), x := ∅, y := singleton(∅))) + thenHave(thesis ) by Substitution.ApplyRules(𝔹.shortDefinition) + } + + val Zero = DEF() --> (∅.typedWith(𝔹)(empty_in_B), 𝔹) + + val One = { + val One = DEF() --> singleton(∅) + val One_in_B = Theorem( (One :: 𝔹) ) { + have(thesis) by Substitution.ApplyRules(One.shortDefinition)(sing_empty_in_B) + } + One.typedWith(𝔹)(One_in_B) + } + + val zero_in_B = Theorem( (Zero :: 𝔹) ) { + have( Zero :: 𝔹) by TypeChecker.prove + } + + +} + +object TypeSystem { + + import TypeLib.{ + |=>, app, f, x, A, B, funcspaceAxiom, any, definition, given + } + + + + type Class = Term | (Term**1 |-> Formula) + + type SmallClass = Term + + case class FunctionalClass(in: Seq[Class], args: Seq[Variable], out: Class, arity: Int) { + def formula[N <: Arity](f: (Term**N |-> Term)): Formula = + val inner = (args.zip(in.toSeq).map((term, typ) => (term is typ).asFormula).reduceLeft((a, b) => a /\ b)) ==> (f.applySeq(args) is out) + args.foldRight(inner)((v, form) => forall(v, form)) + + override def toString(): String = in.map(_.toStringSeparated()).mkString("(", ", ", ")") + " |> " + out.toStringSeparated() + } + object FunctionalClass { + def apply(in: Seq[Class], out: Class, arity: Int): FunctionalClass = FunctionalClass(in, Seq.empty, out, arity) + } + + extension [N <: Arity](f: (Term**N |-> Term)) { + def is (typ: FunctionalClass): FunctionalTypeAssignment[N] & Formula = FunctionalTypeAssignment[N](f, typ).asInstanceOf + } + + extension[A <: Class] (c: Class) { + //(1 to arity).map(i => freshVariable(in.toSeq :+ out, "%x" + i)) + def |>(out: Class): FunctionalClass = FunctionalClass(Seq(c),Seq(freshVariable(Seq(out), "$x")), out, 1) + def |>(out: FunctionalClass): FunctionalClass = + val newVar = freshVariable(out.in.toSeq :+ out.out, "$x") + FunctionalClass(c +: out.in, newVar +: out.args, out.out, out.arity+1) + def toStringSeparated(): String = c match + case t: Term => t.toStringSeparated() + case f: (Term**1 |-> Formula) @unchecked => f.toString() + } + + extension [A <: Class](t: Term) { + def is(clas:A): Formula with TypeAssignment[A] = TypeAssignment(t, clas).asInstanceOf[Formula with TypeAssignment[A]] + def ::(clas:A): Formula with TypeAssignment[A] = TypeAssignment(t, clas).asInstanceOf[Formula with TypeAssignment[A]] + def @@(t2: Term): AppliedFunction = AppliedFunction(t, t2) + def *(t2: Term): AppliedFunction = AppliedFunction(t, t2) + } + + + object * {def unapply(t: Term): Option[(Term, Term)] = t match { + case AppliedFunction(f, a) => Some((f, a)) + case app(f, a) => Some((f, a)) + case _ => None + }} + + + /** + * A type assumption is a pair of a variable and a type. + * It is also a formula, equal to the type applied to the variable. + */ + sealed trait TypeAssignment[A <: Class]{ + this: Formula => + val t: Term + val typ: A + val asFormula: Formula = this + + override def toString() = + t.toStringSeparated() + "::" + typ.toStringSeparated() + override def toStringSeparated(): String = "(" + toString() + ")" + } + object TypeAssignment { + + /** + * A type assumption is a pair of a variable and a type. + * It is also a formula, equal to the type applied to the variable. + */ + def apply[A <: Class](t: Term, typ:A): TypeAssignment[A] = + val form = typ match + case f: Term => in(t, f) + case f : (Term**1 |-> Formula) @unchecked => + ((f: Term**1 |-> Formula)(t): Formula) + form match + case f: VariableFormula => + throw new IllegalArgumentException("Class formula cannot be a variable formula, as we require a type to have no free variable.") + case f: ConstantFormula => new TypeAssignmentConstant(t, typ, f) + case f: AppliedPredicate => new TypeAssignmentPredicate(t, typ, f) + case f: AppliedConnector => new TypeAssignmentConnector(t, typ, f) + case f: BinderFormula => new TypeAssignmentBinder(t, typ, f) + + def unapply(ta: Formula): Option[(Term, Class)] = ta match + case ta: TypeAssignment[?] => Some((ta.t, ta.typ)) + case in(x, set) => Some((x, set)) + case AppliedPredicate(label, args) if label.arity == 1 => Some((args.head, label.asInstanceOf[Term**1 |-> Formula])) + case _ => None + + } + val is = TypeAssignment + + given [A <: Class]: Conversion[TypeAssignment[A], Formula] = _.asInstanceOf[Formula] + /* + given [A <: Class]: Conversion[TypeAssignment[A], Sequent] = ta => Sequent(Set.empty, Set(ta)) + given [A <: Class]: FormulaSetConverter[TypeAssignment[A]] with { + override def apply(f: TypeAssignment[A]): Set[Formula] = Set(f.asInstanceOf[Formula]) + } +*/ + + + private class TypeAssignmentConstant[A <: Class](val t: Term, val typ:A, formula: ConstantFormula) extends ConstantFormula(formula.id) with TypeAssignment[A] + private class TypeAssignmentPredicate[A <: Class](val t: Term, val typ:A, formula: AppliedPredicate) extends AppliedPredicate(formula.label, formula.args) with TypeAssignment[A] { + + override def substituteUnsafe(map: Map[FOL.SchematicLabel[?], FOL.LisaObject[?]]): FOL.Formula = + if map.keySet.exists(_ == typ) then super.substituteUnsafe(map) + else + val newArgs = args.map(_.substituteUnsafe(map)) + if newArgs == args then this else + val newTyp = (typ: LisaObject[?]).substituteUnsafe(map).asInstanceOf[A] + + TypeAssignmentPredicate(t.substituteUnsafe(map), newTyp, formula.copy(args = newArgs)) + } + private class TypeAssignmentConnector[A <: Class](val t: Term, val typ:A, formula: AppliedConnector) extends AppliedConnector(formula.label, formula.args) with TypeAssignment[A] + private class TypeAssignmentBinder[A <: Class](val t: Term, val typ:A, formula: BinderFormula) extends BinderFormula(formula.f, formula.bound, formula.body) with TypeAssignment[A] + + + type TypingContext = Iterable[TypeAssignment[?]] + + + sealed trait FunctionalTypeAssignment[N <: Arity]{ + this: Formula => + val functional: Term**N |-> Term + val typ: FunctionalClass + val asFormula: Formula = this + + + override def toString() = functional.toString() + " : " + typ.toString() + override def toStringSeparated(): String = "(" + toString + ")" + + } + object FunctionalTypeAssignment { + def apply[N <: Arity](functional: Term**N |-> Term, typ: FunctionalClass): FunctionalTypeAssignment[N] = + val form = typ.formula(functional) + form match + case fo: VariableFormula => + throw new IllegalArgumentException("Class formula cannot be a variable formula, as we require a type to have no free variable.") + case fo: ConstantFormula => new FunctionalTypeAssignmentConstant(functional, typ, fo) + case fo: AppliedPredicate => new FunctionalTypeAssignmentPredicate(functional, typ, fo) + case fo: AppliedConnector => new FunctionalTypeAssignmentConnector(functional, typ, fo) + case fo: BinderFormula => new FunctionalTypeAssignmentBinder(functional, typ, fo) + + def unapply[N <: Arity](f: Formula): Option[((Term ** N) |-> Term, FunctionalClass)] = + f match + case ta: FunctionalTypeAssignment[N] => Some((ta.functional, ta.typ)) + case _ => None + } + private class FunctionalTypeAssignmentConstant[N <: Arity](val functional: Term**N |-> Term, val typ: FunctionalClass, formula: ConstantFormula) extends ConstantFormula(formula.id) with FunctionalTypeAssignment[N] + private class FunctionalTypeAssignmentPredicate[N <: Arity](val functional: Term**N |-> Term, val typ: FunctionalClass, formula: AppliedPredicate) extends AppliedPredicate(formula.label, formula.args) with FunctionalTypeAssignment[N] + private class FunctionalTypeAssignmentConnector[N <: Arity](val functional: Term**N |-> Term, val typ: FunctionalClass, formula: AppliedConnector) extends AppliedConnector(formula.label, formula.args) with FunctionalTypeAssignment[N] + private class FunctionalTypeAssignmentBinder[N <: Arity](val functional: Term**N |-> Term, val typ: FunctionalClass, formula: BinderFormula) extends BinderFormula(formula.f, formula.bound, formula.body) with FunctionalTypeAssignment[N] + + + + + + class TypedConstant[A <: Class] + (id: Identifier, val typ: A, val justif: JUSTIFICATION) extends Constant(id) with LisaObject[TypedConstant[A]] { + val formula = TypeAssignment(this, typ) + assert(justif.statement.left.isEmpty && (justif.statement.right.head == formula)) + + override def substituteUnsafe(map: Map[lisa.fol.FOL.SchematicLabel[?], lisa.fol.FOL.LisaObject[?]]): TypedConstant[A] = this + } + + // Function Labels + + + + + + class TypedConstantFunctional[N <: Arity]( + id : Identifier, + arity: N, + val typ: FunctionalClass, + val justif: JUSTIFICATION + ) extends ConstantFunctionLabel[N](id, arity) with LisaObject[TypedConstantFunctional[N]] { + + override def substituteUnsafe(map: Map[lisa.fol.FOL.SchematicLabel[?], lisa.fol.FOL.LisaObject[?]]): TypedConstantFunctional[N] = this + } + + + + + + class AppliedFunction(val func: Term, val arg: Term) extends AppliedFunctional(app, Seq(func, arg)) with LisaObject[AppliedFunction] { + + override def substituteUnsafe(map: Map[lisa.fol.FOL.SchematicLabel[?], lisa.fol.FOL.LisaObject[?]]): AppliedFunction = AppliedFunction(func.substituteUnsafe(map), arg.substituteUnsafe(map)) + + override def toString(): String = + func match + case AppliedFunction(af @ AppliedFunctional(label, args), t1) if label.id.name == "=:=" => + s"(${t1.toStringSeparated()} =:=_${args.head.toStringSeparated()} ${arg.toStringSeparated()})" + case _ => + func.toStringSeparated() + "*(" + arg.toStringSeparated() + ")" + override def toStringSeparated(): String = toString() + } + object AppliedFunction { + def unapply(af: AppliedFunctional): Option[(Term, Term)] = af match + case AppliedFunctional(label, Seq(func, arg)) if label == app => Some((func, arg)) + case _ => None + } + + + + /////////////////////// + ///// Definitions ///// + /////////////////////// + + + class TypedSimpleConstantDefinition[A <: Class](using om: OutputManager)(fullName: String, line: Int, file: String)( + val expression: Term, + out: Variable, + j: JUSTIFICATION, + val typ:A + ) extends SimpleFunctionDefinition[0](fullName, line, file)(lambda[Term, Term](Seq[Variable](), expression).asInstanceOf, out, j) { + val typingName = "typing_" + fullName + val typingJudgement = THM( label :: typ, typingName, line, file, InternalStatement)({ + have(expression :: typ) by TypeChecker.prove + thenHave(thesis) by lisa.automation.Substitution.ApplyRules(getShortDefinition(label).get) + }) + val typedLabel: TypedConstant[A] = TypedConstant(label.id, typ, typingJudgement) + + + } + object TypedSimpleConstantDefinition { + def apply[A <: Class](using om: OutputManager)(fullName: String, line: Int, file: String)(expression: Term, typ:A): TypedSimpleConstantDefinition[A] = { + val intName = "definition_" + fullName + val out = Variable(freshId(expression.allSchematicLabels.map(_.id), "y")) + val defThm = THM(ExistsOne(out, out === expression), intName, line, file, InternalStatement)({ + have(lisa.prooflib.SimpleDeducedSteps.simpleFunctionDefinition(lambda(Seq[Variable](), expression), out)) + }) + new TypedSimpleConstantDefinition(fullName, line, file)(expression, out, defThm, typ) + } + } + extension (d: definitionWithVars[0]) { + inline infix def -->[A<:Class]( + using om: OutputManager, name: sourcecode.FullName, line: sourcecode.Line, file: sourcecode.File)(term:Term, typ: A): TypedConstant[A] = + TypedSimpleConstantDefinition[A](name.value, line.value, file.value)(term, typ).typedLabel + } + + extension (c: Constant) { + def typedWith[A <: Class](typ:A)(justif: JUSTIFICATION) : TypedConstant[A] = + if justif.statement.right.size != 1 || justif.statement.left.size != 0 || !K.isSame((c is typ).asFormula.underlying, justif.statement.right.head.underlying) then + throw new IllegalArgumentException(s"A proof of typing of $c must be of the form ${c :: typ}, but the given justification shows ${justif.statement}.") + else TypedConstant(c.id, typ, justif) + } + + + + + + + + + ///////////////////////// + ///// Type Checking ///// + ///////////////////////// + + object TypeChecker extends ProofTactic { + private val x = variable + + class TypingException(val msg: String) extends Exception(msg) + + def prove(using proof: SetTheoryLibrary.Proof)(bot:lisa.fol.FOL.Sequent): proof.ProofTacticJudgement = + val context = bot.left + var success: proof.ProofTacticJudgement = null + var typingError: proof.ProofTacticJudgement = null + bot.right.find(goal => + goal match + case (term is typ) => + val ptj = typecheck(using SetTheoryLibrary)(context.toSeq, term, Some(typ)) + if ptj.isValid then + success = ptj + true + else + typingError = ptj + false + case _ => false + ) + if success != null then success else if typingError != null then typingError else proof.InvalidProofTactic("The right hand side of the goal must be a typing judgement") + + private def fullFlat(context: Seq[Formula]): Seq[Formula] = context.flatMap{ + case AppliedConnector(And, cunj) => fullFlat(cunj) + case f => Seq(f) + } + + def typecheck(using lib: SetTheoryLibrary.type, proof: lib.Proof)(context: Seq[Formula], term:Term, typ: Option[Class]): proof.ProofTacticJudgement = + val typingAssumptions: Map[Term, Seq[Class]] = fullFlat(context).collect{ + case TypeAssignment(term, typ) => (term, typ) + }.groupBy(_._1).map((t, l) => (t, l.map(_._2))) + + val functionalTypingAssumptions: Map[(? |-> Term), Seq[FunctionalClass]] = context.collect{ + case FunctionalTypeAssignment(func, typ) => (func, typ) + }.groupBy(_._1).map((func, l) => (func, l.map(_._2))) + + TacticSubproof { + context.foreach(assume(_)) + try { + + def innerTypecheck(context2: Map[Term, Seq[Class]], term:Term, typ:Option[Class]): Class= { + val possibleTypes = typingAssumptions.getOrElse(term, Nil) + if typ == Some(any) then + have(term is any) by Restate.from(TypeLib.any.definition of (x := term)) + any + else if typ.isEmpty && possibleTypes.size >=1 then + have(term is possibleTypes.head) by Restate + possibleTypes.head + else if (typ.nonEmpty && possibleTypes.contains(typ.get)) then + have(term is typ.get) by Restate + typ.get + else term match + case tc: TypedConstant[?] => + if typ.isEmpty then + have(tc is tc.typ) by Restate.from(tc.justif) + tc.typ + else if K.isSame((tc is typ.get).asFormula.underlying, (tc is tc.typ).asFormula.underlying) then + have(tc is typ.get) by Restate.from(tc.justif) + typ.get + else throw TypingException("Constant " + tc + " expected to be of type " + typ + " but has type " + tc.typ + ".") + + case AppliedFunction(func, arg) => + val funcType = innerTypecheck(context2, func, None) + val funcProof = lastStep + val argType = innerTypecheck(context2, arg, None) + val argProof = lastStep + funcType match + case inType |=> outType => typ match + case None => + if K.isSame((arg is inType).asFormula.underlying, (arg is argType).asFormula.underlying) then + have(term is outType) by Tautology.from( + funcspaceAxiom of (f := func, x := arg, A:= inType, B:= outType), + funcProof, + argProof + ) + outType + else throw + TypingException("Function " + func + " found to have type " + funcType + ", but argument " + arg + " has type " + argType + " instead of expected " + inType + ".") + case Some(typ) if K.isSame((term is typ).asFormula.underlying, (term is outType).asFormula.underlying) => + if K.isSame((arg is inType).asFormula.underlying, (arg is argType).asFormula.underlying) then + have(term is outType) by Tautology.from( + funcspaceAxiom of (f := func, x := arg, A:= inType, B:= outType), + funcProof, + argProof + ) + typ + else + throw TypingException("Function " + func + " found to have type " + funcType + ", but argument " + arg + " has type " + argType + " instead of expected " + inType + ".") + + case _ => + throw TypingException("Function " + func + " expected to have function type ? |=> " + typ + ", but has type " + funcType + ". ") + case _ => + throw TypingException("Function " + func + " expected to have function type ? |=> " + typ + ", but has type " + funcType + ". Note that terms having multiple different types is only partialy supported.") + + case AppliedFunctional(label, args) => + val (argTypes, argTypesProofs) = args.map(arg => + try (innerTypecheck(context2, arg, None), lastStep) + catch + case e: TypingException => (any, any.definition of (x := arg)) //if no type could be constructed the normal way, we give it "any" + ).unzip + val labelTypes = label match + case label: TypedConstantFunctional[?] => + (label.typ, () => label.justif) +: + functionalTypingAssumptions.getOrElse(label, Nil).map(fc => (fc, () => (have( fc.formula(label.asInstanceOf) ) by Restate) )) + + case _ => functionalTypingAssumptions.getOrElse(label, Nil).map(fc => (fc, () => have( fc.formula(label.asInstanceOf) ) by Restate )) + functionalTypingAssumptions.get(label) + if labelTypes.isEmpty then + throw TypingException("Function " + label + " expected to have type (" + argTypes.mkString(", ") + ") |=> ? but is untyped.") + else + typ match + case None => + labelTypes.find((labelType, step) => + labelType.arity == args.size && + (args zip argTypes).zip(labelType.in.toSeq).forall((argAndTypes, inType) => + K.isSame((argAndTypes._1 is inType).asFormula.underlying, (argAndTypes._1 is argAndTypes._2).asFormula.underlying) // + ) + ) match + case None => + throw TypingException("Function " + label + " expected to have type (" + argTypes.mkString(", ") + ") |=> ? but is assigned " + labelTypes.mkString(" & ") + ". Note that terms having multiple different types is only partialy supported.") + case Some(labelType, step) => + val out: Class = labelType.out + + val in: Seq[Class] = labelType.in.toSeq + //val labelProp = labelType.formula(label.asInstanceOf) + val labelPropStatement = step() + val labInst = labelPropStatement.of(args: _*) + val subst = (labelType.args zip args).map((v, a) => (v := a)) + val newOut: Class = out match { + case t: Term => t.substitute(subst: _*) + case f: (Term**1 |-> Formula) @unchecked => f.substitute(subst: _*) + } + have(term is newOut) by Tautology.from( + (argTypesProofs :+ labInst ) : _* + ) + newOut + case Some(typValue) => + labelTypes.find((labelType, step) => + labelType.arity == args.size && + (args zip argTypes).zip(labelType.in.toSeq).forall((argAndTypes, inType) => + K.isSame((argAndTypes._1 is inType).asFormula.underlying, (argAndTypes._1 is argAndTypes._2).asFormula.underlying) + ) && { + val subst = (labelType.args zip args).map((v, a) => (v := a)) + val newOut: Class = labelType.out match { + case t: Term => t.substitute(subst: _*) + case f: (Term**1 |-> Formula) @unchecked => f.substitute(subst: _*) + } + K.isSame((term is newOut).asFormula.underlying, (term is typValue).asFormula.underlying) + + } + ) match + case None => + throw TypingException("Function " + label + " expected to have type (" + argTypes.mkString(", ") + ") |=> " + typValue + " but is assigned " + labelTypes.mkString(" & ") + ". Note that terms having multiple different types is only partialy supported.") + case Some(labelType, step) => + val out: Class = labelType.out + val in: Seq[Class] = labelType.in.toSeq + //val labelProp = labelType.formula(label.asInstanceOf) + val labelPropStatement = step() + have(term is typValue) by Tautology.from( + (argTypesProofs :+ labelPropStatement.of(args: _*) ) : _* + ) + typValue + + case v: Variable => + if possibleTypes.isEmpty then + throw TypingException("Variable " + v + " expected to be of type " + typ + " but is untyped.") + else throw TypingException("Variable " + v + " expected to be of type " + typ + " but is assigned " + possibleTypes.mkString(" & ") + ".") + + case c: Constant => + if possibleTypes.isEmpty then + throw TypingException("Constant " + c + " expected to be of type " + typ + " but is untyped.") + else throw TypingException("Constant " + c + " expected to be of type " + typ + " but is assigned " + possibleTypes.mkString(" & ") + ".") + + case _: AppliedFunctional => + throw Exception("Why is this not handled by the previous case? Scala reports an incomplete match") + + } + innerTypecheck(typingAssumptions, term, typ) + } + catch { + case e: TypingException => + return proof.InvalidProofTactic(e.msg) + } + } + + + } + + + + + + + + + + +} diff --git a/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Frontend.scala b/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Frontend.scala new file mode 100644 index 000000000..df6d157e3 --- /dev/null +++ b/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Frontend.scala @@ -0,0 +1,566 @@ +package lisa.maths.settheory.types.adt + +/** + * This object provides a DSL for defining algebraic data types (ADTs) and functions over ADT in Lisa. + * For usage examples, please refer to the documentation of the package or the reference manual. + */ +object ADTSyntax { + + import ADTDefinitions.* + import lisa.maths.settheory.SetTheory.{*, given} + + /** + * Builder for defining a constructor specification. + * + * @param param the parameters of the constructor + */ + case class ConstructorBuilder (private val param: Seq[ConstructorArgument]) { + + /** + * The number of arguments the constructor takes + */ + def size: Int = param.length + + /** + * Merges the parameters of two constructors. + * + * @param b the other constructor + */ + infix def ++(b: ConstructorBuilder): ConstructorBuilder = ConstructorBuilder(param ++ b.param.toSeq) + + /** + * Converts this constructor into an ADT with a single constructor. + */ + def toADTBuilder = ADTBuilder(Seq(this)) + + /** + * Combines two constructors into an ADT. + * + * @param b the other constructor + */ + infix def |(b: ConstructorBuilder): ADTBuilder = this | b.toADTBuilder + + /** + * Adds this constructor to an ADT. + * + * @param b the ADT to which the constructor is added + */ + infix def |(b: ADTBuilder): ADTBuilder = toADTBuilder | b + + /** + * Outputs the [[UntypedConstructor]] associated with this builder. + * + * @param name the name of the constructor + */ + def build(variables1: Seq[Variable], variables2: Seq[Variable]): SyntacticConstructor = SyntacticConstructor(param, variables1, variables2) + } + + /** + * Companion object for the [[ConstructorBuilder]] class. + */ + object ConstructorBuilder { + + /** + * Creates an empty [[ConstructorBuilder]]. + */ + def empty: ConstructorBuilder = ConstructorBuilder(Seq.empty) + } + + trait ConstructorConverter[T] { + + /** + * Converts a value into a [[ConstructorBuilder]]. + */ + def apply(t: T): ConstructorBuilder + } + + /** + * Converts a value into a [[ConstructorBuilder]]. + * + * @param any the value to convert + * @param c the converter that is used for the conversion + */ + private def any_to_const[T](any: T)(using c: ConstructorConverter[T]): ConstructorBuilder = c(any) + + given unit_to_const: ConstructorConverter[Unit] with { + + /** + * Converts a unit value into a constructor taking no arguments. + */ + override def apply(u: Unit): ConstructorBuilder = ConstructorBuilder.empty + } + + given empty_to_const: ConstructorConverter[EmptyTuple] with { + + /** + * Converts an empty tuple into a constructor taking no arguments. + */ + override def apply(t: EmptyTuple): ConstructorBuilder = ConstructorBuilder.empty + } + + given term_to_const[T <: Term]: ConstructorConverter[T] with { + + /** + * Converts a term into a constructor taking one non inductive argument. + */ + override def apply(t: T): ConstructorBuilder = ConstructorBuilder(Seq(GroundType(t))) + } + + given adt_to_const[N <: Arity]: ConstructorConverter[ADT[N]] with { + + /** + * Converts an ADT into a constructor taking one inductive argument. + */ + override def apply(a: ADT[N]): ConstructorBuilder = ConstructorBuilder(Seq(Self)) + } + + given adt_tuple_to_const[N <: Arity, T <: Tuple](using ConstructorConverter[T]): ConstructorConverter[ADT[N] *: T] with { + + /** + * Converts a tuple prepended with a type into a constructor taking an argument and whose other arguments are deduced from + * applying recursively the conversion to the tuple. + */ + override def apply(t: ADT[N] *: T): ConstructorBuilder = + any_to_const(t.head) ++ any_to_const(t.tail) + } + + + given term_tuple_to_const[H <: Term, T <: Tuple](using ConstructorConverter[T]): ConstructorConverter[H *: T] with { + + /** + * Converts a tuple prepended with a type into a constructor taking an argument and whose other arguments are deduced from + * applying recursively the conversion to the tuple. + */ + override def apply(t: H *: T): ConstructorBuilder = + any_to_const(t.head) ++ any_to_const(t.tail) + } + + extension [T1](left: T1)(using c1: ConstructorConverter[T1]) + /** + * Converts two values into constructors and combines them into an ADT. + * + * @param right the other value to convert + * @param c2 the implicit converter for the second value + */ + infix def |[T2](right: T2)(using c2: ConstructorConverter[T2]): ADTBuilder = any_to_const(left) | any_to_const(right) + + /** + * Builder for defining ADT specifications. + * + * @param constructors the builders for each constructor of the ADT. + */ + case class ADTBuilder (private val constructors: Seq[ConstructorBuilder]) { + + /** + * The number of constructors in the ADT. + */ + def size: Int = constructors.length + + /** + * Combines this ADT with another one. + * + * @param b the other ADT + */ + infix def |(b: ADTBuilder): ADTBuilder = ADTBuilder(constructors ++ b.constructors) + + /** + * Adds a constructor to this ADT. + * + * @param b the constructor to add + */ + infix def |(b: ConstructorBuilder): ADTBuilder = this | b.toADTBuilder + + /** + * Converts a value into a constructor and adds it to this ADT. + * + * @param t the value to convert + * @param c the implicit converter + */ + infix def |[T](t: T)(using c: ConstructorConverter[T]): ADTBuilder = this | any_to_const(t) + + /** + * Outputs the corresponding ADT and its constructors. + * + * @tparam N the number of type variables appearing in the specification of the ADT + * @param typeVariables the type variables of the ADT + * @param names the names of the constructors and of the ADT + */ + def build[N <: Arity](typeVariables: Variable ** N, names: Seq[String]): (ADT[N], constructors[N]) = + + val trimmedNames = (if size == 0 then names else names.tail).take(size + 1) + require( + trimmedNames.length == constructors.length + 1, + s"The number of new identifiers for constructors must match the given specification.\nNew identifiers: ${names.length - 1}, number of constructors: ${constructors.length}." + ) + + val typeVarsSet = typeVariables.toSeq.toSet + val syntacticCons = constructors.map(c => + c.build(Helpers.chooseVars("x", c.size, typeVarsSet), Helpers.chooseVars("y", c.size, typeVarsSet)) + ) + val syntacticADT = SyntacticADT[N](trimmedNames.head, syntacticCons, typeVariables) + val semanticCons = trimmedNames.tail.zip(syntacticCons).map(SemanticConstructor(_, _, syntacticADT)) + val semanticADT = SemanticADT[N](syntacticADT, semanticCons) + val cons = semanticCons.map(Constructor(_)) + (ADT[N](semanticADT, cons), new constructors[N](cons : _*)) + + } + + /** + * Companion object for the [[ADTBuilder]] class. + */ + object ADTBuilder { + + /** + * Creates an empty [[ADTBuilder]]. + */ + def empty: ADTBuilder = ADTBuilder(Seq.empty) + + /** + * Creates an empty [[ADTBuilder]]. + */ + def | = empty + } + + /** + * Builder for defining polymorphic ADT specifications. + * + * @tparam N the number of type variables of the ADT + * @param typeVariable the type variables of the ADT + * @param specification the builder for ADT + */ + case class PolymorphicADTBuilder[N <: Arity](typeVariables: Variable ** N, specification: ADTBuilder) { + + /** + * Outputs the corresponding ADT and its constructors. + * + * @param names the names of the constructors and of the ADT + */ + def build(names: Seq[String]) = specification.build(typeVariables, names) + + /** + * Adds a constructor to the ADT specification + * + * @param b the builder of the constructor + */ + def | (b: ConstructorBuilder): PolymorphicADTBuilder[N] = PolymorphicADTBuilder(typeVariables, specification | b) + + /** + * Adds a constructor to the ADT specification + * + * @param t the value to be converted into a constructor + */ + def |[T] (t: T)(using ConstructorConverter[T]): PolymorphicADTBuilder[N] = | (any_to_const(t)) + } + + // Syntactic sugar for polymorphic ADT Builders + + extension (u: Unit) + def --> (builder: ADTBuilder): PolymorphicADTBuilder[0] = PolymorphicADTBuilder[0](**(), builder) + def --> (builder: ConstructorBuilder): PolymorphicADTBuilder[0] = --> (builder.toADTBuilder) + def -->[T](t: T)(using ConstructorConverter[T]): PolymorphicADTBuilder[0] = --> (any_to_const(t)) + + extension (v: Variable) + def --> (builder: ADTBuilder): PolymorphicADTBuilder[1] = PolymorphicADTBuilder[1](**(v), builder) + def --> (builder: ConstructorBuilder): PolymorphicADTBuilder[1] = --> (builder.toADTBuilder) + def -->[T](t: T)(using ConstructorConverter[T]): PolymorphicADTBuilder[1] = --> (any_to_const(t)) + + extension (v: (Variable, Variable)) + def --> (builder: ADTBuilder): PolymorphicADTBuilder[2] = PolymorphicADTBuilder[2](**(v._1, v._2), builder) + def --> (builder: ConstructorBuilder): PolymorphicADTBuilder[2] = --> (builder.toADTBuilder) + def -->[T](t: T)(using ConstructorConverter[T]): PolymorphicADTBuilder[2] = --> (any_to_const(t)) + + extension (v: (Variable, Variable, Variable)) + def --> (builder: ADTBuilder): PolymorphicADTBuilder[3] = PolymorphicADTBuilder[3](**(v._1, v._2, v._3), builder) + def --> (builder: ConstructorBuilder): PolymorphicADTBuilder[3] = --> (builder.toADTBuilder) + def -->[T](t: T)(using ConstructorConverter[T]): PolymorphicADTBuilder[3] = --> (any_to_const(t)) + + extension (v: (Variable, Variable, Variable, Variable)) + def --> (builder: ADTBuilder): PolymorphicADTBuilder[4] = PolymorphicADTBuilder[4](**(v._1, v._2, v._3, v._4), builder) + def --> (builder: ConstructorBuilder): PolymorphicADTBuilder[4] = --> (builder.toADTBuilder) + def -->[T](t: T)(using ConstructorConverter[T]): PolymorphicADTBuilder[4] = --> (any_to_const(t)) + + extension (v: (Variable, Variable, Variable, Variable, Variable)) + def --> (builder: ADTBuilder): PolymorphicADTBuilder[5] = PolymorphicADTBuilder[5](**(v._1, v._2, v._3, v._4, v._5), builder) + def --> (builder: ConstructorBuilder): PolymorphicADTBuilder[5] = --> (builder.toADTBuilder) + def -->[T](t: T)(using ConstructorConverter[T]): PolymorphicADTBuilder[5] = --> (any_to_const(t)) + + + /** + * Lists all constructors of this ADT. + */ + case class constructors[N <: Arity](cons: Constructor[N]*) + + /** + * Companion object for the [[constructors]] class. + */ + object constructors { + def unapplySeq[N <: Arity](adt: ADT[N]): Seq[Constructor[N]] = adt.constructors + } + + /** + * Contains useful macros for ADT UI + */ + object Macro { + import scala.quoted._ + + /** + * Extract all the scala identifiers defined in the same line or after an expression. + * + * @param e the expression around which the names are extracted + */ + inline def extractNames[T](e: T): Seq[String] = ${extractNames('{e})} + + /** + * Macro implementing [[this.extractNames]]. + * + * @param e the quoted expression around which the names are extracted + */ + private def extractNames[T](using Quotes)(e: Expr[T]) : Expr[Seq[String]] = + + import quotes.reflect._ + + + val subscope = Symbol.spliceOwner.owner.owner.owner + val scope = subscope.owner + val tree = scope.tree + + case class traverser(s: Symbol) extends TreeTraverser { + var reachedADT: Boolean = false + var constructorNames: Seq[String] = Seq.empty[String] + + override def traverseTree(tree: Tree)(owner: Symbol): Unit = tree match + case v : ValDef => + if !reachedADT then + if v.symbol == s then + constructorNames = constructorNames :+ v.symbol.name + reachedADT = true + else + constructorNames = constructorNames :+ v.symbol.name + + super.traverseTree(tree)(owner) + case _ => super.traverseTree(tree)(owner) + } + + val trav = traverser(subscope) + trav.traverseTree(tree)(scope) + Expr(trav.constructorNames) + } + + /** + * Syntax to define Algebraic Data Types + */ + object define { + /** + * Extracts the constructors from an ADT. + * + * @param adt the ADT + * @return a tuple containing the ADT and its constructors + */ + private def extractConstructors[N <: Arity](adt: ADT[N]): (ADT[N], constructors[N]) = (adt, constructors(adt.constructors : _*)) + + /** + * Outputs a polymorphic ADT and constructors from a user specification + * Needs to be inline in order to fetch the name of the ADT and the constructor. + * + * @param builder the builder user for specifying the ADT + */ + inline def unapply[N <: Arity](builder: PolymorphicADTBuilder[N]): (ADT[N], constructors[N]) = builder.build(Macro.extractNames(builder)) + + /** + * Outputs a (non polymorphic) ADT and constructors from a user specification. + * Needs to be inline in order to fetch the name of the ADT and the constructor. + * + * @param builder the builder user for specifying the ADT + */ + inline def unapply(builder: ADTBuilder): (ADT[0], constructors[0]) = unapply[0](() --> builder) + + /** + * Returns an ADT containing only one constructor out of a user specification. + * Needs to be inline in order to fetch the name of the ADT and the constructor. + * + * @param builder the builder of the unique constructor of the ADT + */ + private inline def unapply(builder: ConstructorBuilder): (ADT[0], constructors[0]) = unapply(builder.toADTBuilder) + + /** + * Returns an ADT isomorphic to a given type. It has only one constructor taking as only argument an element of + * the provided type. + * Needs to be inline in order to fetch the name of the ADT and the constructor. + * + * @param t type given by the user + */ + inline def unapply(t: Term): (ADT[0], constructors[0]) = unapply(term_to_const(t)) + + /** + * Returns the unit type. This is an ADT containing only one value and hence having only one + * constructor (non-inductive and taking no arguments). + * Needs to be inline in order to fetch the name of the ADT and the constructor. + * + * @param u user specification indicating that they want to generate the unit type + */ + inline def unapply(u: Unit): (ADT[0], constructors[0]) = unapply(unit_to_const(u)) + + /** + * Returns a product type (also known as tuple). This is an ADT containing only one constructor. + * Generally its arguments are non inductive as the opposite would lead to the empty type. + * Needs to be inline in order to fetch the name of the ADT and the constructor. + * + * @param t user specification of the tuple + */ + inline def unapply[N <: Arity, T <: Tuple](t: (ADT[N] | Term) *: T)(using ConstructorConverter[T]): (ADT[0], constructors[0]) = + t.head match + case a: ADT[N] => unapply(adt_tuple_to_const(a *: t.tail)) + case term: Term => unapply(any_to_const(term *: t.tail)) + } + + /** + * Converts an ADT with no type variables into a term. + */ + given adt_to_term: Conversion[ADT[0], Term] = _.applyUnsafe(**()) + + /** + * Converts a function over an ADT with no type variables into a term (i.e a set function). + */ + given fun_to_term: Conversion[ADTFunction[0], Term] = _.applyUnsafe(**()) + + /** + * Converts a constructor with no type variables into a term (i.e a set function). + */ + given constructor_to_term: Conversion[Constructor[0], Term] = _.applyUnsafe(**()) + + /** + * Mutable data structure that registers the patterns that have been filled inside a pattern matching syntax. + * + * @tparam N the type variables of the ADT + * @param comp the complementary information stored in the builder + */ + class CaseBuilder[N <: Arity, T, R](val comp : R) { + + /** + * The underlying mutable map between patterns and the body of the corresponding cases. For each + * patterns stores the variables that have been used to represent its arguments. + * + */ + private val underlying = scala.collection.mutable.Map[Constructor[N], (Seq[Variable], T)]() + + /** + * Adds a case to the pattern matching + * + * @param cons the pattern / constructor + * @param value the value next to the variables that are used for the pattern's arguments + */ + def += (cons: Constructor[N], value: (Seq[Variable], T)) = underlying += (cons -> value) + + /** + * Checks if the cases of a pattern matching are valid. Specifically, it checks that: + * - All constructors are covered + * - There are no extra cases + * - The number of variables provided by the user matches the arity of the constructor + * + * @param adt the ADT over which the pattern matching is performed + * @return an error message if the pattern matching is invalid, None otherwise + */ + def isValid(adt: ADT[N]): Option[String] = + val constructors = adt.constructors.toSet + val casesConstructors = underlying.keySet.toSet + + val constructorsMinusCases = constructors -- casesConstructors + val casesMinusConstructors = casesConstructors -- constructors + + // STEP 1: Check that all constructors are covered + if !constructorsMinusCases.isEmpty then + Some(s"Case for ${constructorsMinusCases.head.name} is missing.") + // STEP 2: Check that there are no extra cases + else if !casesMinusConstructors.isEmpty then + Some(s"${casesMinusConstructors.head.name} is not a constructor of ${adt.name}.") + else + underlying.keys.foldLeft[Option[String]](None)((acc, c) => + val vars = underlying(c)._1.toSet + // STEP 3: Check that for each case the number of variables provided by the user matches the arity of the constructor + acc.orElse(Some(s"Case ${c.name}: ${vars.size} variables were provided whereas the arity of ${c.name} is ${c.arity}.").filter(_ => vars.size != c.underlying.arity)) + ) + + /** + * Outputs an immutable map out of the underlying mutable one + */ + def build: Map[Constructor[N], (Seq[Variable], T)] = underlying.toMap + } + + /** + * Case of a a pattern matching syntax + * + * @param cons the pattern / constructor + * @param vars variables that are used to represent the arguments of the constructor + */ + case class Case[N <: Arity](cons: Constructor[N], vars: Variable*) { + + /** + * Used in the context of an induction proof. Adds the subproof corresponding to this case into a builder. + * + * @see [[Induction]] + * + * @param proof the outer scope of the induction proof + * @param line the line at which this case is defined. Usually fetched automatically by the compiler. + * Used for error reporting + * @param file the file in which this case is defined. Usually fetched automatically by the compiler. + * Used for error reporting + * @param builder the builder of the induction proof + * @param subproof the proof of the case (possibly using the induction hypothesis) + */ + def subproof (using proof: Proof, line: sourcecode.Line, file: sourcecode.File, builder: CaseBuilder[N, proof.ProofStep, (Sequent, Seq[Term], Variable)])(subproof: proof.InnerProof ?=> Unit): Unit = + val (bot, args, adtVar) = builder.comp + val prop = bot.right.head + val consTerm = appSeq(cons.underlying.term(args))(vars) + val subst = adtVar -> consTerm + + val assumptions = + (wellTypedSet(cons.underlying.semanticSignature(vars).map(p => (p._1, p._2.substitute(cons.underlying.typeVariablesSeq.zip(args).map(SubstPair(_, _)) : _*)))) + ++ + cons.underlying.syntacticSignature(vars).filter(_._2 == Self).map((v, _) => prop.substitute(adtVar -> v))) + + //val botWithAssumptions = bot.substitute(subst) ++ ((assumptions ++ proof.getAssumptions) |- ()) + val botWithAssumptions = bot.substitute(subst) ++ (assumptions |- ()) + + + + val iProof: proof.InnerProof = new proof.InnerProof(Some(botWithAssumptions)) + subproof(using iProof) + val proofStep = (new SUBPROOF(using proof)(None)(iProof)).judgement.validate(line, file).asInstanceOf[proof.ProofStep] + + def subproofWithExtraStep: proof.ProofTacticJudgement = TacticSubproof{ ip ?=> + val fullSeq = Tautology(using lisa.SetTheoryLibrary, ip)(proofStep)(botWithAssumptions) + if fullSeq.isValid then + fullSeq.validate(line, file) + else + return proof.InvalidProofTactic(s"Proof of case ${cons.name} is invalid.\nExpected: ${botWithAssumptions}.") + } + + builder += (cons, (vars, subproofWithExtraStep.validate(line, file))) + + /** + * Used in the context of a function definition. Adds the body of the case to a builder. + * + * @param body the body of this case + * @param builder the builder for the function definition + */ + def apply(body : Term)(using builder: CaseBuilder[N, Term, Unit]) = builder += (cons, (vars, body)) + } + + /** + * Defines a function over an ADT + * + * @param adt the domain of this function + * @param returnType the return type of this function + * @param name the name of this functions + * @param cases the definition of the function for each constructor + */ + def fun[N <: Arity](adt: ADT[N], returnType: Term)(using name: sourcecode.Name)(cases: CaseBuilder[N, Term, Unit] ?=> Unit): ADTFunction[N] = { + val builder = CaseBuilder[N, Term, Unit](()) + cases(using builder) + builder.isValid(adt) match + case None => + ADTFunction(SemanticFunction[N](name.value, adt.underlying, builder.build.map((k, v) => (k.underlying, v)), returnType), adt) + case Some(msg) => throw IllegalArgumentException(msg) + } + +} \ No newline at end of file diff --git a/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Functions.scala b/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Functions.scala new file mode 100644 index 000000000..0c67f2ea1 --- /dev/null +++ b/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Functions.scala @@ -0,0 +1,134 @@ +/** + * Defines set theoretic functions over Algebraic Data Types + */ + +package lisa.maths.settheory.types.adt + +import lisa.maths.settheory.SetTheory.{_, given} +import lisa.maths.settheory.types.TypeLib.|=> +import lisa.maths.settheory.types.TypeSystem.:: +import lisa.maths.settheory.types.TypeSystem._ + +import ADTDefinitions.* +import Helpers.* +import Helpers.{/\, ===, \/} + +/** + * Set theoretic interpretation of a function over an ADT. + * + * @tparam N the number of type variables of the domain of this function + * @param name the name of this function + * @param adt the domain of this function + * @param cases the body of this function for each constructor + * @param returnType the codomain of this function + * @param line the line at which this function is defined. Usually fetched automatically by the compiler. + * Used for error reporting + * @param file the file in which this function is defined. Usually fetched automatically by the compiler. + * Used for error reporting + */ +class SemanticFunction[N <: Arity](name: String, adt: SemanticADT[N], cases: Map[SemanticConstructor[N], (Seq[Variable], Term)], returnType: Term)(using line: sourcecode.Line, file: sourcecode.File) { + + /** + * Map binding each constructor to a theorem stating that the case is well typed. + */ + private val checkReturnType: Map[SemanticConstructor[N], THM] = + (for c <- cases.keys yield + val (vars, body) = cases(c) + c -> Lemma(wellTyped(c.semanticSignature(vars)) |- body :: returnType) { + have(thesis) by TypeChecker.prove + } + ).toMap + + /** + * Type variables appearing in this function's domain. + */ + val typeVariables: Variable ** N = adt.typeVariables + + /** + * Sequence of type variables appearing in this function's domain. + */ + val typeVariablesSeq: Seq[Variable] = adt.typeVariablesSeq + + /** + * Number of type variables appearing in this function. + */ + val typeArity: N = adt.typeArity + + /** + * Full name of this function. That is the name of the function prefixed by the name of the ADT. + */ + val fullName = s"$name" + // val fullName = s"${adt.name}/$name" + + val typ = adt.term |=> returnType + + /** + * Definition of this function. + * + * Formally it is the only function whose domain is the ADT and such that for each constructor c f * (c * x1 * ... * xn) = case(c, x1, ..., xn) + */ + private val untypedDefinition = (f :: typ) /\ simplify(/\(cases.map((c, caseDef) => + val (vars, body) = caseDef + forallSeq(vars, wellTypedFormula(c.semanticSignature(vars)) ==> (f * c.appliedTerm(vars) === body)) + ))) + + /** + * Lemma --- Uniqueness of this function. + */ + private val uniqueness = Axiom(existsOne(f, untypedDefinition)) + + /** + * Set theoretic definition of the constructor. + */ + private val classFunction = FunctionDefinition(fullName, line.value, file.value)(typeVariablesSeq, f, untypedDefinition, uniqueness).label + + /** + * Identifier of this function. + */ + val id: Identifier = classFunction.id + + + /** + * Function where type variables are instantiated with schematic symbols. + */ + val term = classFunction.applySeq(typeVariablesSeq) + + /** + * Lemma --- The body of this function correpsonds to the cases provided by the user. + * + * `for each constructor c, ∀x1, ..., xn. f * (c * x1 * ... * xn) = case(c, x1, ..., xn)` + */ + val shortDefinition = cases.map((c, caseDef) => + val (vars, body) = caseDef + c -> Lemma(simplify(wellTypedFormula(c.semanticSignature(vars))) ==> (term * c.appliedTerm(vars) === body)) { + have(forall(f, (term === f) <=> untypedDefinition)) by Exact(classFunction.definition) + thenHave((term === term) <=> (term :: typ) /\ (/\(cases.map((c, caseDef) => { + val (vars, body) = caseDef + forallSeq(vars, wellTypedFormula(c.semanticSignature(vars)) ==> (term * c.appliedTerm(vars) === body)) + })))) by InstantiateForall(term) + thenHave(forallSeq(vars, wellTypedFormula(c.semanticSignature(vars)) ==> (term * c.appliedTerm(vars) === body))) by Weakening + vars.foldLeft(lastStep)((l, _) => + lastStep.statement.right.head match + case Forall(v, phi) => thenHave(phi) by InstantiateForall(v) + case _ => throw UnreachableException + ) + } + ) + + /** + * Lemma --- Introduction rule + * + * `f : ADT -> T` + * + * where `T` is the return type of this function + */ + val intro = Lemma(forallSeq(typeVariablesSeq, term :: typ)) { + have(forall(f, (term === f) <=> untypedDefinition)) by Exact(classFunction.definition) + thenHave((term === term) <=> (term :: typ) /\ (/\(cases.map((c, caseDef) => { + val (vars, body) = caseDef + forallSeq(vars, /\(wellTyped(c.semanticSignature(vars))) ==> (term * c.appliedTerm(vars) === body)) + })))) by InstantiateForall(term) + thenHave(term :: typ) by Weakening + thenHave(thesis) by QuantifiersIntro(typeVariablesSeq) + } +} diff --git a/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Helpers.scala b/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Helpers.scala new file mode 100644 index 000000000..5830f1aab --- /dev/null +++ b/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Helpers.scala @@ -0,0 +1,1030 @@ +package lisa.maths.settheory.types.adt + +/** + * Tactic that proves every goal of the form: + * + * ` ... |- ..., ∀x1, ..., xn. P(x), ...` + * + * ` ..., ∀x1, ..., xn . P(x), ... |- ...` + * + * ` ... |- ..., ∃x1, ..., xn. P(x), ...` + * + * ` ..., ∃x1, ..., xn . P(x), ... |- ...` + * + * given a proof of the sequents without quantification. + */ +object QuantifiersIntro extends lisa.prooflib.ProofTacticLib.ProofTactic { + + import lisa.prooflib.SimpleDeducedSteps.Restate + import lisa.prooflib.BasicStepTactic.* + import lisa.fol.FOL.* + + /** + * Executes the tactic on a specific goal. + * + * @param lib the library that is currently being used + * @param proof the ongoing proof in which the tactic is called + * @param vars the variables that needs to be quantified + * @param fact the proof of the sequent without quantification + * @param bot the statement to prove + */ + def apply(using lib: lisa.prooflib.Library, proof: lib.Proof)(vars: Seq[Variable])(fact: proof.Fact)(bot: Sequent): proof.ProofTacticJudgement = + TacticSubproof { sp ?=> + if vars.isEmpty then + lib.have(bot) by Restate.from(fact) + else + val diff: Sequent = bot -- fact.statement + + diff match + case Sequent(s, _) if s.size == 1 => + val diffRest = bot.left -- s + val f = s.head + val fWithoutQuant = (fact.statement.left -- diffRest).head + f match + case BinderFormula(Forall, _, _) => + vars.foldRight[(sp.Fact, Formula)](fact, fWithoutQuant)( (v, acc) => + val (accFact, accFormula) = acc + val newFormula = forall(v, accFormula) + (lib.have(diffRest + newFormula |- bot.right) by LeftForall(accFact), newFormula) + ) + case BinderFormula(Exists, _, _) => + vars.foldRight[(sp.Fact, Formula)](fact, fWithoutQuant)( (v, acc) => + val (accFact, accFormula) = acc + val newFormula = exists(v, accFormula) + (lib.have(diffRest + newFormula |- bot.right) by LeftExists(accFact), newFormula) + ) + case _ => return proof.InvalidProofTactic(s"The formula that changed is not quantified: $f.") + case Sequent(_, s) if s.size == 1 => + val diffRest = bot.right -- s + val f = s.head + val fWithoutQuant = (fact.statement.right -- diffRest).head + f match + case BinderFormula(Forall, _, _) => + vars.foldRight[(sp.Fact, Formula)](fact, fWithoutQuant)( (v, acc) => + val (accFact, accFormula) = acc + val newFormula = forall(v, accFormula) + (lib.have(bot.left |- diffRest + newFormula) by RightForall(accFact), newFormula) + ) + case BinderFormula(Exists, _, _) => + vars.foldRight[(sp.Fact, Formula)](fact, fWithoutQuant)( (v, acc) => + val (accFact, accFormula) = acc + val newFormula = exists(v, accFormula) + (lib.have(bot.left |- diffRest + newFormula) by RightExists(accFact), newFormula) + ) + case _ => return proof.InvalidProofTactic(s"The formula that changed is not quantified: $f.") + case Sequent(s1, s2) if s1.isEmpty && s2.isEmpty => lib.have(bot) by Restate.from(fact) + case _ => return proof.InvalidProofTactic("Two or more formulas in the sequent have changed.") + + + } +} + +/** + * General purpose helpers. + */ +private [adt] object Helpers { + + import lisa.fol.FOL.{*, given} + + /** + * Benchmarks a block of code. + * + * @param name the name of the benchmark + * @param f the block of code to benchmark + * @return the result of the block of code and prints how long it took to execute + */ + def benchmark[T](name: String)(f: => T): T = { + val before = System.nanoTime + + val res = f + + val totalTime = (System.nanoTime - before) / 1000000 + + println(s"$name time: $totalTime ms") + + res + } + + /** + * Exception thrown when code that should not be accessed is reached. + */ + object UnreachableException extends Exception("This code should not be accessed. If you see this message, please report it to the library maintainers.") + + // ********************* + // * FIRST ORDER LOGIC * + // ********************* + + val a = variable + val b = variable + val c = variable + val d = variable + + val f = variable + val g = variable + val h = variable + + val n = variable + val m = variable + + val p = formulaVariable + val p1 = formulaVariable + val p2 = formulaVariable + val p3 = formulaVariable + val p4 = formulaVariable + + val q1 = formulaVariable + val q2 = formulaVariable + + val r = variable + val s = variable + val t = variable + + val x = variable + val y = variable + val z = variable + + val Q = predicate[1] + val P = predicate[1] + val P2 = predicate[2] + val schemPred = predicate[1] + + /** + * Formula representing whether two sequences of terms are pairwise equal. + * + * @param s2 the sequence to compare with + */ + extension (s1: Seq[Term]) def ===(s2: Seq[Term]): Formula = /\(s1.zip(s2).map(_ === _)) + + /** + * Disjunction of a sequence of formulas. + * + * @param s the formulas to which the disjunction is applied + */ + def \/(s: Iterable[Formula]): Formula = + if s.isEmpty then False + else s.fold(False)(_ \/ _) + + /** + * Conjunction of a sequence of formulas. + * + * @param s the formulas to which the conjunction is applied + */ + def /\(s: Iterable[Formula]): Formula = + if s.isEmpty then True + else s.fold(True)(_ /\ _) + + /** + * Repeats existential quantification over a sequence of variables. + * + * @param vars the variables to quantify over + * @param f the formula to which the quantifiers are applied + * @return the quantified formula + */ + def existsSeq(vars: Seq[Variable], f: Formula): Formula = + vars.foldRight(f)(exists(_, _)) + + /** + * Repeats universal quantification over a sequence of variables. + * + * @param vars the variables to quantify over + * @param f the formula to which the quantifiers are applied + * @return the quantified formula + */ + def forallSeq(vars: Seq[Variable], f: Formula): Formula = + vars.foldRight(f)(forall(_, _)) + + /** + * Simplifies a formula by removing True and False constants. + * + * @param f the formula to simplify + */ + def simplify(f: Formula): Formula = + f match + case Or(False, phi) => simplify(phi) + case Or(phi, False) => simplify(phi) + case Or(phi, psi) => simplify(phi) \/ simplify(psi) + case And(True, phi) => simplify(phi) + case And(phi, True) => simplify(phi) + case And(phi, psi) => simplify(phi) /\ simplify(psi) + case Implies(True, phi) => simplify(phi) + case Implies(phi, psi) => Implies(simplify(phi), simplify(psi)) + case _ => f + + + /** + * Picks fresh variables starting with a given prefix . + * + * @param prefix the prefix of the fresh variables + * @param size the number of fresh variables to output + * @param assigned the variables that are already used + * @param counter the index to append to the prefix + * @param acc the variables that have already been generated by this method + * + */ + def chooseVars(prefix: String, size: Int, assigned: Set[Variable] = Set.empty, counter: Int = 0, acc: Seq[Variable] = Seq.empty): Seq[Variable] = + if size == 0 then + acc + else + val newVar = Variable(s"${prefix}${counter}") + if assigned.contains(newVar) then + chooseVars(prefix, size, assigned, counter + 1, acc) + else + chooseVars(prefix, size - 1, assigned, counter + 1, acc :+ newVar) + + +} + +/** + * Definitions and helper functions for ADT. + */ +private[adt] object ADTDefinitions { + + import lisa.maths.settheory.SetTheory.* + import lisa.maths.settheory.types.TypeSystem.* + import Helpers.{/\} + + /** + * The specification of a constructor can either contain terms or a self reference, i.e. a reference to the ADT itself. + */ + trait ConstructorArgument { + /** + * Returns the term associated to a constructor argument, or in case it is a self reference, returns the term associated to the ADT. + * + * @param arg the constructor argument + * @param adt the term representing the ADT + */ + def getOrElse(adt: Term): Term = + this match { + case Self => adt + case GroundType(term) => term + } + + /** + * Substitutes the type variables of a constructor argument. + */ + def substitute(p: SubstPair*): ConstructorArgument = + this match + case Self => Self + case GroundType(t) => GroundType(t.substitute(p : _*)) + } + + /** + * A symbol for self reference + */ + case object Self extends ConstructorArgument + + /** + * Syntactic represenation of a term + * + * @param t the underlying term + */ + case class GroundType(t: Term) extends ConstructorArgument + + /** + * Shorthand for the union of the range of a function. + * + * @param f the function + */ + def unionRange(f: Term) = union(relationRange(f)) + + /** + * Shorthand for the range of a restricted function. + * + * @param f the function + * @param n the domain to which the function is restricted + */ + def restrRange(f: Term, n: Term) = relationRange(restrictedFunction(f, n)) + + /** + * Applies a sequence of arguments to a function. + * + * @param f the function + * @param args the arguments to apply + */ + def appSeq(f: Term)(args: Seq[Term]): Term = args.foldLeft(f)(_ * _) + + /** + * Converts an integer to the associated ordinal. + * + * @param n the integer to convert + */ + def toTerm(n: Int): Term = + require(n >= 0, "n must be a non-negative integer") + if n == 0 then emptySet + else successor(toTerm(n - 1)) + + /** + * Returns a sequence of formulas asserting that all terms of a sequence are well-typed. + * + * @param s the terms and their respective types + */ + def wellTyped(s: Seq[(Term, Term)]): Seq[Formula] = s.map(_ :: _) + + /** + * Returns a sequence of formulas asserting that all terms of a sequence are well-typed with respect to the + * specification of a constructor. + * + * @param s the terms and their respective type + * @param orElse the term to use in case of a self reference + */ + def wellTyped(s: Seq[(Term, ConstructorArgument)])(orElse: Term): Seq[Formula] = s.map((t, arg) => t :: arg.getOrElse(orElse)) + + /** + * Returns a set of formulas asserting that all terms of a sequence are well-typed. + * + * @param s the terms and their respective types + */ + def wellTypedSet(s: Seq[(Term, Term)]): Set[Formula] = wellTyped(s).toSet + + /** + * Returns a set of formulas asserting that all terms of a sequence are well-typed with respect to the + * specification of a constructor. + * + * @param s the terms and their respective type + * @param orElse the term to use in case of a self reference + */ + def wellTypedSet(s: Seq[(Term, ConstructorArgument)])(orElse: Term): Set[Formula] = wellTyped(s)(orElse).toSet + + /** + * Returns a formula asserting that all terms of a sequence are well-typed. + * + * @param s the terms and their respective types + */ + def wellTypedFormula(s: Seq[(Term, Term)]): Formula = /\ (wellTyped(s)) + + /** + * Returns a formula asserting that all terms of a sequence are well-typed with respect to the + * specification of a constructor. + * + * @param s the terms and their respective type + * @param orElse the term to use in case of a self reference + */ + def wellTypedFormula(s: Seq[(Term, ConstructorArgument)])(orElse: Term): Formula = /\ (wellTyped(s)(orElse)) + +} + + +/** + * List of external set theoretic theorems needed for proofs about ADT. + * Some of these theorems are not yet implemented in the library and + * will be added in the future. + */ +private [adt] object ADTHelperTheorems { + + import lisa.maths.settheory.SetTheory.{*, given} + import lisa.maths.Quantifiers.{existentialEquivalenceDistribution, equalityInExistentialQuantifier, + existentialConjunctionWithClosedFormula, equalityTransitivity} + import ADTDefinitions.* + import Helpers.* + //import lisa.maths.Quantifiers.* + + // TODO: Remove + val pair = ConstantFunctionLabel("pair", 2) + addSymbol(pair) + + val pairExtensionality = Lemma((pair(a, b) === pair(c, d)) <=> ((a === c) /\ (b === d))) { + sorry + } + + // ********************* + // * FIRST ORDER LOGIC * + // ********************* + + + /** + * Lemma --- Alternative statement of transitivity of equality. + */ + val altEqualityTransitivity = Lemma((x === y, y === z) |- x === z) { + have(thesis) by Restate.from(equalityTransitivity) + } + + /** + * Lemma --- Transitivity of equivalence. + */ + val equivalenceRewriting = Lemma((p1 <=> p2, p2 <=> p3) |- p1 <=> p3) { + have(thesis) by Tautology + } + + /** + * Lemma --- Modus ponens for equivalence. + */ + val equivalenceApply = Lemma((p1 <=> p2, p1) |- p2) { + have(thesis) by Tautology + } + + /** + * Lemma --- Top level existential quantifiers can be swapped. + */ + val existentialSwap = Lemma(∃(x, ∃(y, P2(x, y))) <=> ∃(y, ∃(x, P2(x, y)))) { + have(thesis) by Tableau + } + + /** + * Lemma --- Modus ponens for reversed equivalence. + */ + val equivalenceRevApply = Lemma((p2 <=> p1, p1) |- p2) { + have(thesis) by Tautology + } + + /** + * Lemma --- If a statement is equivalent to the conjunction of two other statements, and one of them is true, then it can be removed from the equivalence. + */ + val equivalenceAnd = Lemma((p2, p1 <=> (p2 /\ p3)) |- p1 <=> p3) { + have(thesis) by Tautology + } + + /** + * Lemma --- If two formulas are equivalent then adding a disjunction on their right side preserves the equivalence. + */ + val rightAndEquivalence = Lemma(p1 <=> p2 |- (p1 /\ p) <=> (p2 /\ p)) { + have(thesis) by Tautology + } + + /** + * Lemma --- If two formulas are equivalent then adding an implication on their left side preserves the equivalence. + */ + val impliesEquivalence = Lemma((p1 <=> p2, p3 <=> p4) |- (p1 ==> p3) <=> (p2 ==> p4)) { + have(thesis) by Tautology + } + + /** + * Lemma --- If two formulas are equivalent then adding an implication on their left side preserves the equivalence. + */ + val leftImpliesEquivalenceWeak = Lemma(p1 <=> p2 |- (p ==> p1) <=> (p ==> p2)) { + have(thesis) by Tautology + } + + /** + * Lemma --- Implication distributes over equivalence. + */ + val leftImpliesEquivalenceStrong = Lemma(p ==> (p1 <=> p2) |- (p ==> p1) <=> (p ==> p2)) { + have(thesis) by Tautology + } + + /** + * Lemma --- If there exists a unique element satisfying a predicate, then all + * other elements satisfying the predicate are equal to it. + */ + val existsOneUniqueness = Lemma((∃!(x, P(x)), P(x), P(y)) |- x === y) { + sorry + } + + // ******************* + // * NATURAL NUMBERS * + // ******************* + + // Natural numbers + val N = Constant("N") + addSymbol(N) + + /** + * Lemma --- 0 is a natural number. + * + * `0 ∈ N` + */ + val zeroIsNat = Lemma(in(emptySet, N)) { + sorry + } + + /** + * Lemma --- The natural numbers are not empty. + * + * `N != ∅` + */ + val natNotEmpty = Lemma(!(N === emptySet)) { + have(thesis) by Cut(zeroIsNat, setWithElementNonEmpty of (y := emptySet, x := N)) + } + + /** + * Lemma --- There exists a natural number. + * + * `∃n ∈ N` + */ + val existsNat = Lemma(exists(n, in(n, N))) { + have(thesis) by RightExists(zeroIsNat) + } + + /** + * Lemma --- Successor is an injective function. + * + * `n = m <=> n + 1 = m + 1` + */ + val successorInjectivity = Lemma((n === m) <=> (successor(n) === successor(m))) { + sorry + } + + /** + * Lemma --- A term is a natural number if and only if its successor is a natural number. + * + * `n ∈ N <=> n + 1 ∈ N` + */ + val successorIsNat = Lemma(in(n, N) <=> in(successor(n), N)) { + sorry + } + + /** + * Lemma --- Any number is smaller than its successor + * + * `∀n ∈ N. n < n + 1` + */ + val inSuccessor = Lemma(in(n, successor(n))) { + val uniomAxiomForward = have(exists(y, in(y, unorderedPair(n, singleton(n))) /\ in(n, y)) |- in(n, union(unorderedPair(n, singleton(n))))) by Cut( + unionAxiom of (x := unorderedPair(n, singleton(n)), z := n), + equivalenceRevApply of (p1 := exists(y, in(y, unorderedPair(n, singleton(n))) /\ in(n, y)), p2 := in(n, union(unorderedPair(n, singleton(n))))) + ) + have(in(singleton(n), unorderedPair(n, singleton(n))) /\ in(n, singleton(n))) by RightAnd( + secondElemInPair of (x := n, y := singleton(n)), + singletonHasNoExtraElements of (x := n, y := n) + ) + thenHave(exists(y, in(y, unorderedPair(n, singleton(n))) /\ in(n, y))) by RightExists + have(in(n, union(unorderedPair(n, singleton(n))))) by Cut(lastStep, uniomAxiomForward) + thenHave(union(unorderedPair(n, singleton(n))) === successor(n) |- in(n, successor(n))) by RightSubstEq.withParametersSimple( + List((union(unorderedPair(n, singleton(n))), successor(n))), + lambda(s, in(n, s)) + ) + have(thesis) by Cut(successor.shortDefinition of (x := n), lastStep) + } + + /** + * Lemma --- 0 is not the successor of any natural number. + * + * `∀n ∈ N. n + 1 != 0` + */ + val zeroIsNotSucc = Lemma(!(successor(n) === emptySet)) { + have(thesis) by Cut(inSuccessor, setWithElementNonEmpty of (y := n, x := successor(n))) + } + + /** + * Lemma --- A number is smaller or equal than another number if and only if it is strictly smaller than its successor. + * + * `m <= n <=> m < n + 1` + */ + val natSubset = Lemma(in(n, N) |- subset(m, n) <=> in(m, successor(n))) { + sorry + } + + /** + * Lemma --- The intersection of a natural number with the set of natural numbers is the number itself. + * + * `n ∩ N = n` + */ + val intersectionNat = Lemma(in(n, N) |- setIntersection(n, N) === n) { + sorry + } + + /** + * Lemma --- If a number is smaller or equal than a natural number, then it is also a natural number. + * + * `m <= n, n ∈ N |- m ∈ N` + */ + val subsetIsNat = Lemma(subset(a, b) |- in(b, N) ==> in(a, N)) { + sorry + } + + /** + * Lemma --- Induction principle for natural numbers + * + * `P(0), ∀n ∈ N. P(n) => P(n + 1) |- ∀n ∈ N. P(n)` + */ + val natInduction = Lemma((P(emptySet), forall(m, in(m, N) ==> (P(m) ==> P(successor(m))))) |- forall(n, in(n, N) ==> P(n))) { + sorry + } + + /** + * Lemma --- Every number is smaller or equal than its successor. + * + * `n <= n + 1` + */ + val subsetSuccessor = Lemma(subset(n, successor(n))) { + have(setUnion(n, singleton(n)) === union(unorderedPair(n, singleton(n))) |- subset(n, union(unorderedPair(n, singleton(n))))) by RightSubstEq.withParametersSimple( + List((setUnion(n, singleton(n)), union(unorderedPair(n, singleton(n))))), + lambda(s, subset(n, s)) + )(unionSubsetFirst of (a := n, b := singleton(n))) + have(subset(n, union(unorderedPair(n, singleton(n))))) by Cut(setUnion.shortDefinition of (x := n, y := singleton(n)), lastStep) + thenHave(successor(n) === union(unorderedPair(n, singleton(n))) |- subset(n, successor(n))) by RightSubstEq.withParametersSimple( + List((successor(n), union(unorderedPair(n, singleton(n))))), + lambda(s, subset(n, s)) + ) + have(thesis) by Cut(successor.shortDefinition of (x := n), lastStep) + } + + // ************* + // * FUNCTIONS * + // ************* + + /** + * Lemma --- Range introduction and elimination rules. If en element is in the image of a function, then it has a preimage inside its domain. + * + * `functional(f) |- y ⊆ Im(f) <=> ∃x ∈ Dom(f). f(x) = y` + */ + val functionRangeMembership = Lemma(functional(f) |- in(y, relationRange(f)) <=> ∃(x, in(x, relationDomain(f)) /\ (app(f, x) === y))) { + sorry + } + + /** + * Lemma --- The restriction of a function is still a function. + * + * `functional(f) |- functional(f|x)` + */ + val functionalRestrictedFunction = Lemma(functional(f) |- functional(restrictedFunction(f, x))) { + sorry + } + + /** + * Lemma --- If an element is in the image of a restricted function, then it has a preimage inside its domain. + * + * `functional(f) |- y ⊆ Im(f) <=> ∃x ∈ d ∩ Dom(f). f|d(x) = y` + */ + val restrictedFunctionRangeMembership = Lemma(functional(f) |- in(y, relationRange(restrictedFunction(f, d))) <=> ∃(x, in(x, d ∩ relationDomain(f)) /\ (app(restrictedFunction(f, d), x) === y))) { + have(functional(f) |- in(y, relationRange(restrictedFunction(f, d))) <=> ∃(x, in(x, relationDomain(restrictedFunction(f, d))) /\ (app(restrictedFunction(f, d), x) === y))) by Cut( + functionalRestrictedFunction of (x := d), + functionRangeMembership of (f := restrictedFunction(f, d)) + ) + thenHave(functional(f) |- in(y, relationRange(restrictedFunction(f, d))) <=> ∃(x, in(x, d ∩ relationDomain(f)) /\ (app(restrictedFunction(f, d), x) === y))) by Substitution.ApplyRules( + restrictedFunctionDomain of (x := d) + ) + } + + /** + * Lemma --- Characterization of the union of the range of a function. + * + * `∪ Im(h) = {z | ∃n ∈ Dom(h). z ∈ h(n)}` + */ + val unionRangeMembership = Lemma(functional(h) |- in(z, unionRange(h)) <=> exists(n, in(n, relationDomain(h)) /\ in(z, app(h, n)))) { + val iffAfterAnd = have(functional(h) |- (y ∈ relationRange(h) /\ z ∈ y) <=> ∃(m, m ∈ relationDomain(h) /\ (app(h, m) === y)) /\ z ∈ y) by Cut( + functionRangeMembership of (f := h), + rightAndEquivalence of (p1 := y ∈ relationRange(h), p2 := ∃(m, m ∈ relationDomain(h) /\ (app(h, m) === y)), p := z ∈ y) + ) + have(functional(h) |- (y ∈ relationRange(h) /\ z ∈ y) <=> ∃(m, m ∈ relationDomain(h) /\ (app(h, m) === y) /\ z ∈ y)) by Apply(equivalenceRewriting).on( + iffAfterAnd, + existentialConjunctionWithClosedFormula of (P := lambda(m, m ∈ relationDomain(h) /\ (app(h, m) === y)), p := z ∈ y) + ) + + thenHave(functional(h) |- ∀(y, (y ∈ relationRange(h) /\ z ∈ y) <=> ∃(m, m ∈ relationDomain(h) /\ (app(h, m) === y) /\ z ∈ y))) by RightForall + + val beforeExSwap = have(functional(h) |- ∃(y, y ∈ relationRange(h) /\ z ∈ y) <=> ∃(y, ∃(m, m ∈ relationDomain(h) /\ (app(h, m) === y) /\ z ∈ y))) by Cut( + lastStep, + existentialEquivalenceDistribution of ( + P := lambda(y, y ∈ relationRange(h) /\ z ∈ y), + Q := lambda(y, ∃(m, m ∈ relationDomain(h) /\ (app(h, m) === y) /\ z ∈ y)) + ) + ) + + have(∃(y, ∃(m, m ∈ relationDomain(h) /\ (app(h, m) === y) /\ z ∈ y)) <=> ∃(m, ∃(y, m ∈ relationDomain(h) /\ z ∈ y /\ (app(h, m) === y)))) subproof { + + have(m ∈ relationDomain(h) /\ (app(h, m) === y) /\ z ∈ y <=> m ∈ relationDomain(h) /\ z ∈ y /\ (app(h, m) === y)) by Restate + thenHave(forall(y, m ∈ relationDomain(h) /\ (app(h, m) === y) /\ z ∈ y <=> m ∈ relationDomain(h) /\ z ∈ y /\ (app(h, m) === y))) by RightForall + have(∃(y, m ∈ relationDomain(h) /\ (app(h, m) === y) /\ z ∈ y) <=> ∃(y, m ∈ relationDomain(h) /\ z ∈ y /\ (app(h, m) === y))) by Cut( + lastStep, + existentialEquivalenceDistribution of ( + P := lambda(y, m ∈ relationDomain(h) /\ (app(h, m) === y) /\ z ∈ y), + Q := lambda(y, m ∈ relationDomain(h) /\ z ∈ y /\ (app(h, m) === y)) + ) + ) + thenHave(forall(m, ∃(y, m ∈ relationDomain(h) /\ (app(h, m) === y) /\ z ∈ y) <=> ∃(y, m ∈ relationDomain(h) /\ z ∈ y /\ (app(h, m) === y)))) by RightForall + have(∃(m, ∃(y, m ∈ relationDomain(h) /\ (app(h, m) === y) /\ z ∈ y)) <=> ∃(m, ∃(y, m ∈ relationDomain(h) /\ z ∈ y /\ (app(h, m) === y)))) by Cut( + lastStep, + existentialEquivalenceDistribution of ( + P := lambda(y, ∃(y, m ∈ relationDomain(h) /\ (app(h, m) === y) /\ z ∈ y)), + Q := lambda(y, ∃(y, m ∈ relationDomain(h) /\ z ∈ y /\ (app(h, m) === y))) + ) + ) + have(thesis) by Apply(equivalenceRewriting).on(lastStep, existentialSwap of (P2 := lambda((y, m), m ∈ relationDomain(h) /\ (app(h, m) === y) /\ z ∈ y))) + } + + val introM = + have(functional(h) |- ∃(y, y ∈ relationRange(h) /\ z ∈ y) <=> ∃(m, ∃(y, m ∈ relationDomain(h) /\ z ∈ y /\ (app(h, m) === y)))) by Apply(equivalenceRewriting).on(beforeExSwap, lastStep) + + have( + ∀(m, (∃(y, m ∈ relationDomain(h) /\ z ∈ y /\ (app(h, m) === y))) <=> (m ∈ relationDomain(h) /\ z ∈ app(h, m))) + ) by RightForall(equalityInExistentialQuantifier of (P := lambda(y, m ∈ relationDomain(h) /\ z ∈ y), y := app(h, m))) + + have( + ∃(m, (∃(y, m ∈ relationDomain(h) /\ z ∈ y /\ (app(h, m) === y)))) <=> ∃(m, m ∈ relationDomain(h) /\ z ∈ app(h, m)) + ) by Cut( + lastStep, + existentialEquivalenceDistribution of ( + P := lambda(m, ∃(y, m ∈ relationDomain(h) /\ z ∈ y /\ (app(h, m) === y))), + Q := lambda(m, m ∈ relationDomain(h) /\ z ∈ app(h, m)) + ) + ) + + have(functional(h) |- ∃(y, y ∈ relationRange(h) /\ z ∈ y) <=> ∃(m, m ∈ relationDomain(h) /\ z ∈ app(h, m))) by Apply(equivalenceRewriting).on( + introM, + lastStep + ) + + have(thesis) by Apply(equivalenceRewriting).on( + lastStep, + unionAxiom.asInstanceOf + ) + } + + // ************* + // * EMPTYNESS * + // ************* + + /** + * Lemma --- The union of the empty set is the empty set. + * + * `∪ ∅ = ∅` + */ + val unionEmpty = Lemma(union(emptySet) === emptySet) { + sorry + } + + /** + * Lemma --- Restricting the domain of a function to the empty set yields the empty set. + * + * `h|∅ = ∅` + */ + val restrictedFunctionEmptyDomain = Lemma(restrictedFunction(h, emptySet) === emptySet) { + sorry + } + + /** + * Lemma --- If the domain of a function is non empty, then the function is non empty as well. + * + * `Dom(h) != ∅ |- h != ∅` + */ + val nonEmptyDomain = Lemma(!(relationDomain(h) === emptySet) |- !(h === emptySet)) { + sorry + } + + /** + * Lemma --- A superset of a non empty set is non empty. + * + * `x ⊆ y, x != ∅ |- y != ∅` + */ + val subsetNotEmpty = Lemma((subset(x, y), !(x === emptySet)) |- !(y === emptySet)) { + val subst = have(y === emptySet |- y === emptySet) by Hypothesis + have((subset(x, emptySet), y === emptySet) |- (x === emptySet)) by Apply(equivalenceApply of (p1 := subset(x, emptySet))).on(emptySetIsItsOwnOnlySubset.asInstanceOf) + thenHave((subset(x, y), y === emptySet) |- (x === emptySet)) by Substitution.ApplyRules(subst) + } + + /** + * Theorem --- The range of the empty relation is empty. + * + * `range(∅) = ∅` + * + */ + val rangeEmpty = Theorem(relationRange(emptySet) === emptySet) { + import lisa.maths.settheory.SetTheory + + have(!in(SetTheory.pair(a, t), emptySet)) by Exact(emptySetAxiom) + thenHave(forall(a, !in(SetTheory.pair(a, t), emptySet))) by RightForall + val s0 = thenHave(!exists(a, in(SetTheory.pair(a, t), emptySet))) by Restate + + have(!in(t, emptySet)) by Exact(emptySetAxiom) + have(in(t, emptySet) <=> exists(a, in(SetTheory.pair(a, t), emptySet))) by Tautology.from(lastStep, s0) + val defRHS = thenHave(forall(t, in(t, emptySet) <=> exists(a, in(SetTheory.pair(a, t), emptySet)))) by RightForall + + have((relationRange(emptySet) === emptySet) <=> forall(t, in(t, emptySet) <=> exists(a, in(SetTheory.pair(a, t), emptySet)))) by InstantiateForall(emptySet)( + relationRange.definition of (r := emptySet, z := emptySet) + ) + have(relationRange(emptySet) === emptySet) by Tautology.from(defRHS, lastStep) + } + + + /** + * Lemma --- The range of the empty function is empty. + * + * `Im(∅) = ∅` + */ + val unionRangeEmpty = Lemma(unionRange(emptySet) === emptySet) { + have(unionRange(emptySet) === unionRange(emptySet)) by RightRefl + thenHave(unionRange(emptySet) === union(emptySet)) by Substitution.ApplyRules(rangeEmpty) + thenHave(thesis) by Substitution.ApplyRules(unionEmpty) + } + + /** + * Lemma --- If a function and a domain are non empty, then restricting this function to this + * domain yields a non empty set. + * + * `h != ∅, d != ∅ |- h|d != ∅` + */ + val restrictedFunctionNotEmpty = Lemma((!(h === emptySet), !(d === emptySet)) |- !(restrictedFunction(h, d) === emptySet)) { + sorry + } + + // **************** + // * MONOTONICITY * + // **************** + + /** + * Lemma --- Union is a monotonic operation with respect to set inclusion. + * + * `x ⊆ y |- ∪ x ⊆ ∪ y` + */ + val unionMonotonic = Lemma(subset(x, y) |- subset(union(x), union(y))) { + sorry + } + + /** + * Lemma --- Range is a monotonic operation with respect to set inclusion. + * + * `f ⊆ g |- Im(f) ⊆ Im(g)` + */ + val rangeMonotonic = Lemma(subset(f, g) |- subset(relationRange(f), relationRange(g))) { + sorry + } + + /** + * Lemma --- The union of the range is a monotonic operation with respect to set inclusion. + * + * `f ⊆ g |- ∪ Im(f) ⊆ ∪ Im(g)` + */ + val unionRangeMonotonic = Lemma(subset(f, g) |- subset(unionRange(f), unionRange(g))) { + have(thesis) by Apply(unionMonotonic).on(rangeMonotonic.asInstanceOf) + } + + /** + * Lemma --- If two implications are true then disjuncting on both sides is also a valid implication. + */ + val disjunctionsImplies = Lemma((p1 ==> p2, q1 ==> q2) |- (p1 \/ q1) ==> (p2 \/ q2)) { + + val right = have((p1 ==> p2, q1 ==> q2, p1) |- p2 \/ q2) by Restate + val left = have((p1 ==> p2, q1 ==> q2, q1) |- p2 \/ q2) by Restate + + have((p1 ==> p2, q1 ==> q2, p1 \/ q1) |- p2 \/ q2) by LeftOr(left, right) + } + + /** + * Lemma --- If a class function F (whose representation is P) is monotonic then with respect to set inclusion, then S -> F(S) ∪ S is also + * a monotonic function. + * + * `s ⊆ t, F(s) ⊆ F(t) |- F(s) ∪ s ⊆ F(t) ∪ t` + */ + val unionPreimageMonotonic = Lemma((subset(s, t), P(s) ==> P(t)) |- (P(s) \/ in(x, s)) ==> (P(t) \/ in(x, t))) { + have(subset(s, t) |- forall(z, in(z, s) ==> in(z, t))) by Cut( + subsetAxiom of (x := s, y := t), + equivalenceApply of (p1 := subset(s, t), p2 := forall(z, in(z, s) ==> in(z, t))) + ) + thenHave(subset(s, t) |- in(x, s) ==> in(x, t)) by InstantiateForall(x) + have(thesis) by Cut(lastStep, disjunctionsImplies of (p1 := in(x, s), p2 := in(x, t), q1 := P(s), q2 := P(t))) + } + + /** + * Lemma --- Resticting a function to a smaller domain yields a subset of the original function. + * + * `x ⊆ y |- f|x ⊆ f|y` + */ + val restrictedFunctionDomainMonotonic = Lemma(subset(x, y) |- subset(restrictedFunction(f, x), restrictedFunction(f, y))) { + sorry + } + + // ******************* + // * SPECIFIC LEMMAS * + // ******************* + + /** + * Lemma --- Characterization of the union of the range of a cumulative function restricted to the successor of a natural number. + * + * `cumulative(h) and Dom(h) = N |- ∪ Im(h|n + 1) = h(n)` + */ + val unionRangeCumulativeRestrictedFunction = + Lemma((functional(h), relationDomain(h) === N, in(n, N), ∀(m, subset(m, n) ==> subset(app(h, m), app(h, n)))) |- unionRange(restrictedFunction(h, successor(n))) === app(h, n)) { + + val domainSubset = have(in(n, N) |- setIntersection(successor(n), N) === successor(n)) by Apply(intersectionNat).on(equivalenceApply of (p1 := in(n, N)), successorIsNat.asInstanceOf) + + have(functional(h) |- (y ∈ restrRange(h, successor(n)) /\ z ∈ y) <=> ∃(m, m ∈ (successor(n) ∩ relationDomain(h)) /\ (app(restrictedFunction(h, successor(n)), m) === y)) /\ z ∈ y) by Cut( + restrictedFunctionRangeMembership of (f := h, d := successor(n)), + rightAndEquivalence of (p1 := y ∈ restrRange(h, successor(n)), p2 := ∃(m, m ∈ (successor(n) ∩ relationDomain(h)) /\ (app(restrictedFunction(h, successor(n)), m) === y)), p := z ∈ y) + ) + + thenHave( + (functional(h), relationDomain(h) === N) |- (y ∈ restrRange(h, successor(n)) /\ z ∈ y) <=> ∃(m, m ∈ (successor(n) ∩ N) /\ (app(restrictedFunction(h, successor(n)), m) === y)) /\ z ∈ y + ) by RightSubstEq.withParametersSimple( + List((relationDomain(h), N)), + lambda(s, (y ∈ restrRange(h, successor(n)) /\ z ∈ y) <=> ∃(m, m ∈ (successor(n) ∩ s) /\ (app(restrictedFunction(h, successor(n)), m) === y)) /\ z ∈ y) + ) + + thenHave( + (functional(h), in(n, N), relationDomain(h) === N, successor(n) ∩ N === successor(n)) |- (y ∈ restrRange(h, successor(n)) /\ z ∈ y) <=> ∃( + m, + m ∈ (successor(n) ∩ N) /\ (app(restrictedFunction(h, successor(n)), m) === y) + ) /\ z ∈ y + ) by Weakening + + thenHave( + (functional(h), in(n, N), relationDomain(h) === N, successor(n) ∩ N === successor(n)) |- (y ∈ restrRange(h, successor(n)) /\ z ∈ y) <=> ∃( + m, + m ∈ successor(n) /\ (app(restrictedFunction(h, successor(n)), m) === y) + ) /\ z ∈ y + ) by RightSubstEq.withParametersSimple( + List((successor(n) ∩ N, successor(n))), + lambda(s, (y ∈ restrRange(h, successor(n)) /\ z ∈ y) <=> ∃(m, m ∈ s /\ (app(restrictedFunction(h, successor(n)), m) === y)) /\ z ∈ y) + ) + + have( + (functional(h), in(n, N), relationDomain(h) === N) |- (y ∈ restrRange(h, successor(n)) /\ z ∈ y) <=> ∃(m, m ∈ successor(n) /\ (app(restrictedFunction(h, successor(n)), m) === y)) /\ z ∈ y + ) by Cut(domainSubset, lastStep) + + have( + (functional(h), in(n, N), relationDomain(h) === N) |- (y ∈ restrRange(h, successor(n)) /\ z ∈ y) <=> ∃(m, m ∈ successor(n) /\ (app(restrictedFunction(h, successor(n)), m) === y) /\ z ∈ y) + ) by Apply(equivalenceRewriting).on( + lastStep, + existentialConjunctionWithClosedFormula of (P := lambda(m, m ∈ successor(n) /\ (app(restrictedFunction(h, successor(n)), m) === y)), p := z ∈ y) + ) + + thenHave( + (functional(h), in(n, N), relationDomain(h) === N) |- ∀( + y, + (y ∈ restrRange(h, successor(n)) /\ z ∈ y) <=> ∃(m, m ∈ successor(n) /\ (app(restrictedFunction(h, successor(n)), m) === y) /\ z ∈ y) + ) + ) by RightForall + + have( + (functional(h), in(n, N), relationDomain(h) === N) |- ∃(y, y ∈ restrRange(h, successor(n)) /\ z ∈ y) <=> ∃( + y, + ∃(m, m ∈ successor(n) /\ (app(restrictedFunction(h, successor(n)), m) === y) /\ z ∈ y) + ) + ) by Cut( + lastStep, + existentialEquivalenceDistribution of ( + P := lambda(y, y ∈ restrRange(h, successor(n)) /\ z ∈ y), + Q := lambda(y, ∃(m, m ∈ successor(n) /\ (app(restrictedFunction(h, successor(n)), m) === y) /\ z ∈ y)) + ) + ) + + val introM = + thenHave( + (functional(h), in(n, N), relationDomain(h) === N) |- ∃(y, y ∈ restrRange(h, successor(n)) /\ z ∈ y) <=> ∃( + m, + ∃(y, m ∈ successor(n) /\ z ∈ y /\ (app(restrictedFunction(h, successor(n)), m) === y)) + ) + ) by Tableau + + have((∃(y, m ∈ successor(n) /\ z ∈ y /\ (app(restrictedFunction(h, successor(n)), m) === y))) <=> (m ∈ successor(n) /\ z ∈ app(restrictedFunction(h, successor(n)), m))) by Exact( + equalityInExistentialQuantifier of (P := lambda(y, m ∈ successor(n) /\ z ∈ y)) + ) + + thenHave(m ∈ successor(n) |- (∃(y, m ∈ successor(n) /\ z ∈ y /\ (app(restrictedFunction(h, successor(n)), m) === y))) <=> (m ∈ successor(n) /\ z ∈ app(h, m))) by Substitution.ApplyRules( + restrictedFunctionApplication + ) + thenHave((∃(y, m ∈ successor(n) /\ z ∈ y /\ (app(restrictedFunction(h, successor(n)), m) === y))) <=> (m ∈ successor(n) /\ z ∈ app(h, m))) by Tableau + + thenHave(subset(m, n) <=> m ∈ successor(n) |- (∃(y, m ∈ successor(n) /\ z ∈ y /\ (app(restrictedFunction(h, successor(n)), m) === y))) <=> (subset(m, n) /\ z ∈ app(h, m))) by RightSubstIff + .withParametersSimple( + List((m ∈ successor(n), subset(m, n))), + lambda(p, (∃(y, m ∈ successor(n) /\ z ∈ y /\ (app(restrictedFunction(h, successor(n)), m) === y))) <=> (p /\ z ∈ app(h, m))) + ) + + have(in(n, N) |- (∃(y, m ∈ successor(n) /\ z ∈ y /\ (app(restrictedFunction(h, successor(n)), m) === y))) <=> (subset(m, n) /\ z ∈ app(h, m))) by Cut(natSubset, lastStep) + + thenHave( + in(n, N) |- ∀(m, (∃(y, m ∈ successor(n) /\ z ∈ y /\ (app(restrictedFunction(h, successor(n)), m) === y))) <=> (subset(m, n) /\ z ∈ app(h, m))) + ) by RightForall + + have( + in(n, N) |- ∃(m, (∃(y, m ∈ successor(n) /\ z ∈ y /\ (app(restrictedFunction(h, successor(n)), m) === y)))) <=> ∃(m, subset(m, n) /\ z ∈ app(h, m)) + ) by Cut( + lastStep, + existentialEquivalenceDistribution of ( + P := lambda(m, ∃(y, m ∈ successor(n) /\ z ∈ y /\ (app(restrictedFunction(h, successor(n)), m) === y))), + Q := lambda(m, subset(m, n) /\ z ∈ app(h, m)) + ) + ) + + have((functional(h), in(n, N), relationDomain(h) === N) |- ∃(y, y ∈ restrRange(h, successor(n)) /\ z ∈ y) <=> ∃(m, subset(m, n) /\ z ∈ app(h, m))) by Apply(equivalenceRewriting).on( + introM, + lastStep + ) + + val unionIsExists = + have((functional(h), in(n, N), relationDomain(h) === N) |- z ∈ unionRange(restrictedFunction(h, successor(n))) <=> ∃(m, subset(m, n) /\ z ∈ app(h, m))) by Apply(equivalenceRewriting).on( + lastStep, + unionAxiom.asInstanceOf + ) + + val cumulativeAssumption = ∀(m, subset(m, n) ==> subset(app(h, m), app(h, n))) + + have(cumulativeAssumption |- ∃(m, subset(m, n) /\ z ∈ app(h, m)) <=> z ∈ app(h, n)) subproof { + val seq1 = have(z ∈ app(h, n) |- z ∈ app(h, n)) by Hypothesis + have(z ∈ app(h, n) |- subset(n, n) /\ z ∈ app(h, n)) by RightAnd(seq1, subsetReflexivity of (x := n)) + thenHave(z ∈ app(h, n) |- ∃(m, subset(m, n) /\ z ∈ app(h, m))) by RightExists + val backward = thenHave(cumulativeAssumption |- z ∈ app(h, n) ==> ∃(m, subset(m, n) /\ z ∈ app(h, m))) by Weakening + + have(cumulativeAssumption |- cumulativeAssumption) by Hypothesis + thenHave(cumulativeAssumption |- subset(m, n) ==> subset(app(h, m), app(h, n))) by InstantiateForall(m) + have((cumulativeAssumption, subset(m, n), z ∈ app(h, m)) |- forall(z, z ∈ app(h, m) ==> z ∈ app(h, n))) by Apply(equivalenceApply).on( + lastStep, + subsetAxiom + ) + thenHave((cumulativeAssumption, subset(m, n) /\ z ∈ app(h, m)) |- z ∈ app(h, n)) by InstantiateForall(z) + thenHave((cumulativeAssumption, ∃(m, subset(m, n) /\ z ∈ app(h, m))) |- z ∈ app(h, n)) by LeftExists + val forward = thenHave(cumulativeAssumption |- ∃(m, subset(m, n) /\ z ∈ app(h, m)) ==> z ∈ app(h, n)) by RightImplies + + have(thesis) by RightIff(forward, backward) + } + + have((functional(h), in(n, N), relationDomain(h) === N, cumulativeAssumption) |- (z ∈ unionRange(restrictedFunction(h, successor(n)))) <=> z ∈ app(h, n)) by Apply(equivalenceRewriting).on( + unionIsExists, + lastStep + ) + thenHave((functional(h), in(n, N), relationDomain(h) === N, cumulativeAssumption) |- ∀(z, z ∈ unionRange(restrictedFunction(h, successor(n))) <=> z ∈ app(h, n))) by RightForall + + have(thesis) by Apply(equivalenceApply).on(lastStep, extensionalityAxiom.asInstanceOf) + } + +} diff --git a/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Tactics.scala b/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Tactics.scala new file mode 100644 index 000000000..cb8250798 --- /dev/null +++ b/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Tactics.scala @@ -0,0 +1,174 @@ +/** + * Defines a set of tactics to reason on Algebraic Data Types + */ + +package lisa.maths.settheory.types.adt + +import lisa.maths.settheory.SetTheory.{*, given} +import ADTDefinitions.* +import Helpers.* + +/** + * Tactic performing a structural induction proof over an algebraic data type. + * + * ===Usage=== + * {{{ + * have(forall(x, x :: adt => P(x)) /*or*/ x :: adt |- P(x)) by Induction(x, adt) { + * Case(c1, x1, ..., xn) subproof { + * // proof of P(xi) /\ ... P(xj) => P(c1(x1, ..., xn)) + * } + * ... + * Case(cm, x1, ..., xk) subproof { + * // proof of P(xi) /\ ... P(xj) => P(c1(x1, ..., xn')) + * } + * } + * }}} + * + * x and adt are inferred from the context if not provided by the user. + * + * Supports only 1 formula on the right hand side of the sequent. + * @param expectedVar the variable on which the induction is performed + * @param expectedADT the algebraic data type on which the induction is performed + */ +class Induction[M <: Arity](expectedVar: Option[Variable], expectedADT: Option[ADT[M]]) extends lisa.prooflib.ProofTacticLib.ProofTactic { + + /** + * Given a proof of the claim for each case (possibly using the induction hypothesis), + * reassemble them to generate a proof of the claim of the form + * `∀x. x :: adt => P(x)` + * + * @param proof the proof in which the induction is performed + * @param cases the proofs of the claim for each case in addition to the variables used by the user + * @param inductionVariable the variable over which the induction is performed + * @param adt the algebraic data type to perform induction on + * @param prop the property to prove //TODO: Change to a lambda expression (Scala 3.4.2) + */ + private def proveForallPredicate[N <: Arity](using proof: lisa.SetTheoryLibrary.Proof)(cases: Map[Constructor[N], (Seq[Variable], proof.Fact)], inductionVariable: Variable, adt: ADT[N], typeVariablesSubst: Seq[Term], propFun: Term => Formula, context: Set[Formula]): proof.Fact = + + val prop = lambda[Term, Formula](x, propFun(x)) + val typeVariablesSubstPairs = adt.typeVariables.toSeq.zip(typeVariablesSubst).map(SubstPair(_, _)) + val instTerm = adt(typeVariablesSubst : _*) + + adt.constructors.foldLeft[proof.Fact](adt.induction.of((typeVariablesSubstPairs :+ (P := prop)): _*)) ( (acc, c) => + val inductiveCaseProof = cases(c)._1.zip(c.underlying.underlying.specification.map(_.substitute(typeVariablesSubstPairs : _*))).foldRight[proof.Fact](cases(c)._2) ( (el, acc2) => + val (v, ty) = el + val accRight: Formula = acc2.statement.right.head + ty match + case Self => + have((acc2.statement - accRight) by Weakening(acc2) + thenHave((lastStep.statement - (prop(v) ==> accRight)) by Weakening + thenHave(lastStep.statement.left |- forall(v, v :: instTerm ==> (prop(v) ==> accRight))) by RightForall + case GroundType(t)=> + thenHave((acc2.statement - accRight) by Weakening + thenHave(lastStep.statement.left |- forall(v, v :: t ==> accRight)) by RightForall + ) + acc.statement.right.head match + case Implies(trueInd, rest) => + // println(s"Case: ${c.fullName}") + // println(isSame(trueInd, inductiveCaseProof.statement.right.head)) + // println(inductiveCaseProof.statement) + // println(" + ") + // println(acc.statement) + // println(" = ") + // println((acc.statement.left ++ inductiveCaseProof.statement.left) |- rest) + have((acc.statement.left ++ inductiveCaseProof.statement.left) |- rest) by Sorry//Cut(inductiveCaseProof, acc) + case _ => throw UnreachableException + ) + thenHave(context |- forall(inductionVariable, inductionVariable :: instTerm ==> prop(inductionVariable))) by Tautology //Change + + + + /** + * Infers the variable, the ADT and the arguments of the ADT from a formula of the form `x :: ADT(T1, ..., Tn)`. + * + * @param f the formula to infer these elements from + */ + def inferArguments(f: Formula): Option[(Variable, ADT[?], Seq[Term])] = + def checkFoundArguments(foundVar: Variable, foundADT: ADT[?], args: Seq[Term]): Option[(Variable, ADT[?], Seq[Term])] = + (expectedVar, expectedADT) match + case (Some(v), _) if v != foundVar => None + case (_, Some(a)) if a != foundADT => None + case _ => Some((foundVar, foundADT, args)) + + f match + case TypeAssignment(Variable(id), ADT(foundADT, args)) => + checkFoundArguments(Variable(id), foundADT, args) + case AppliedPredicate(in, Seq[Term](Variable(id), ADT(foundADT, args))) => + checkFoundArguments(Variable(id), foundADT, args) + case _ => + None + + /** + * Infers the variable, the ADT and the arguments of the ADT from a set of formula + * containing one is of the form `x :: ADT(T1, ..., Tn)`. + * + * @param s the set of formula to infer these elements from + */ + def inferArguments(s: Set[Formula]): Option[(Variable, ADT[?], Seq[Term])] = + s.foldLeft[Option[(Variable, ADT[?], Seq[Term])]](None)((acc, prem) => + acc.orElse(inferArguments(prem)) + ) + + /** + * Infers the variable, the ADT and the arguments of the ADT from a sequent whose one of the premises + * is of the form `x :: ADT(T1, ..., Tn)`. + * + * @param seq the sequent to infer these elements from + */ + def inferArguments(seq: Sequent): Option[(Variable, ADT[?], Seq[Term], Option[Formula])] = + inferArguments(seq.left).map(p => (p._1, p._2, p._3, None)) + .orElse( + seq.right.head match + case Forall(x, Implies(assignment, prop)) => + inferArguments(assignment).filter(p => p._1 == x).map(p => (p._1, p._2, p._3, Some(prop))) + case _ => None + ) + + /** + * Given a proof of the claim for each case (possibly using the induction hypothesis), + * reassemble the subproofs to generate a proof of the claim for every element of the ADT. + * + * @tparam N the arity of the ADT + * @param proof the scope in which the induction is performed + * @param cases the cases to prove. A [[CaseBuilder]] is a mutable data structure that register every case that + * has been added to the tactic. + * @param bot the claim + */ + def apply[N <: Arity](using proof: lisa.SetTheoryLibrary.Proof)(cases: ADTSyntax.CaseBuilder[N, proof.ProofStep, (Sequent, Seq[Term], Variable)] ?=> Unit)(bot: Sequent): proof.ProofTacticJudgement = + inferArguments(bot) match + case Some((inferedVar, inferedADT, inferedArgs, inferedProp)) => + + val prop = inferedProp.getOrElse(bot.right.head) + val propFunction = (t: Term) => inferedProp.getOrElse(bot.right.head).substitute(inferedVar -> t) + val assignment = inferedVar :: inferedADT(inferedArgs : _*) + val context = (if inferedProp.isDefined then bot else bot -<< assignment).left + val builder = ADTSyntax.CaseBuilder[N, proof.ProofStep, (Sequent, Seq[Term], Variable)]((context |- prop, inferedArgs, inferedVar)) + cases(using builder) + + builder.isValid(inferedADT.asInstanceOf[ADT[N]]) match + case None => + TacticSubproof { sp ?=> + proveForallPredicate(using sp)(builder.build, inferedVar, inferedADT.asInstanceOf[ADT[N]], inferedArgs, propFunction, context) + if !inferedProp.isDefined then + lastStep.statement.right.head match + case Forall(_, phi) => + thenHave(context |- phi) by InstantiateForall(inferedVar) + case _ => throw UnreachableException + + thenHave(bot) by Tautology + } + case Some(msg) => proof.InvalidProofTactic(msg) + + case None => proof.InvalidProofTactic("No variable typed with the ADT found in the context.") + +} + +/** + * Companion object for the [[Induction]] tactic class. + */ +object Induction { + def apply()(using proof: lisa.SetTheoryLibrary.Proof) = new Induction(None, None) + def apply[N <: Arity](adt: ADT[N])(using proof: lisa.SetTheoryLibrary.Proof) = new Induction(None, Some(adt)) + def apply(v: Variable)(using proof: lisa.SetTheoryLibrary.Proof) = new Induction(Some(v), None) + def apply[N <: Arity](v: Variable, adt: ADT[N])(using proof: lisa.SetTheoryLibrary.Proof) = new Induction(Some(v), Some(adt)) +} \ No newline at end of file diff --git a/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Typed.scala b/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Typed.scala new file mode 100644 index 000000000..4b1ed5713 --- /dev/null +++ b/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Typed.scala @@ -0,0 +1,285 @@ +/** + * Gives a type theoretic interpretation to algebraic data types and functions over them. + */ + +package lisa.maths.settheory.types.adt + +import lisa.maths.settheory.SetTheory.{_, given} +import lisa.maths.settheory.types.TypeLib.any +import lisa.maths.settheory.types.TypeSystem.FunctionalClass +import lisa.maths.settheory.types.TypeSystem.TypedConstantFunctional + +/** + * Type theoretic interpretation of a constructor, that is a function whose type is + * + * `c :: ∀X1, ..., Xn. T1 -> ... -> Tn -> ADT + * + * @tparam N the number of type variables appearing in the definition of this constructor's ADT + * @param line the line at which this constructor is defined. Usually fetched automatically by the compiler. + * Used for error reporting + * @param file the file in which this constructor is defined. Usually fetched automatically by the compiler. + * Used for error reporting + * @param underlying the set theoretic underlying constructor + */ +class Constructor[N <: Arity] private[adt] (using line: sourcecode.Line, file: sourcecode.File)( + private[adt] val underlying: SemanticConstructor[N] +) extends TypedConstantFunctional[N]( + underlying.fullName, + underlying.typeArity, + FunctionalClass(Seq.fill(underlying.typeArity)(any), underlying.typeVariablesSeq, underlying.typ, underlying.typeArity), + underlying.intro + ) { + + /** + * Name of the constructor + * + * e.g `list/cons` or `list/nil` + */ + val name = underlying.fullName + + /** + * Theorem --- Introduction rule + * + * `c :: ∀X1, ..., Xn. T1 -> ... -> Tn -> ADT + * + * where `c` is this constructor, `ADT` the ADT it belongs to and `T1, ..., Tn` the domains of the constructor's arguments. + * X1, ..., Xn are the type variables of the ADT. + */ + val intro = + THM(underlying.intro.statement, s"${name} introduction rule", line.value, file.value, Theorem) { + have(underlying.intro) + } + + /** + * Theorem --- Injectivity + * + * ` c(x1, ..., xn) = c(y1, ..., yn) <=> x1 = y1 /\ ... /\ xn = yn` + */ + lazy val injectivity = + THM(underlying.injectivity.statement, s"${name} injectivity", line.value, file.value, Theorem) { + have(underlying.injectivity) + } + + /** + * Type variables appearing in the signature of this constructor + */ + val typeVariables: Variable ** N = underlying.typeVariables +} + +/** + * Type theoretic polymorphic inductive datatype. Comes with a structural induction schema, injection and pattern matching. + * + * @tparam N the number of type variables appearing in the definition of this ADT + * @param line the line at which this ADT is defined. Usually fetched automatically by the compiler. + * Used for error reporting + * @param file the file in which this ADT is defined. Usually fetched automatically by the compiler. + * Used for error reporting + * @param underlying + * @param constructors + */ +class ADT[N <: Arity] private[adt] (using line: sourcecode.Line, file: sourcecode.File)( + private[adt] val underlying: SemanticADT[N], + private[adt] val constructors: Seq[Constructor[N]] +) { + + /** + * Name of this ADT + */ + val name = underlying.name + + /** + * Identifier of this ADT. + */ + val id: Identifier = underlying.id + ADT.identifiersToADT.addOne(id -> this) + + /** + * Theorem --- Structural induction principle + * + * e.g. `P(nil) => (∀x :: T, l :: list(T). P(l) => P(cons(x, l)))) => ∀l :: list(T). P(l)` + */ + lazy val induction = + THM(underlying.induction.statement, s"${name} structural induction principle", line.value, file.value, Theorem) { + have(underlying.induction) + } + + /** + * Theorem --- Elimination rules (Pattern Matching) + * + * `x :: ADT |- ∃ x1, ..., xn. x = c1 * x1 * ... * xn \/ ... \/ ∃ x1, ..., xn'. x = cm * x1 * ... * xn' + * + * Every term of this ADT is an instance of one of its constructors. + * + * e.g. `∀l :: list(T). l = nil \/ ∃x, xs. l = cons(x, xs)` + */ + lazy val elim = + THM(underlying.elim.statement, s"${name} elimination rule", line.value, file.value, Theorem) { + have(underlying.elim) + } + + /** + * Theorem --- Injectivity + * + * ` c1 * x1 * ... * xn != c2 * y1 * ... * ym` + * + * Instances of different constructors are different. + * + * e.g. `cons(x, l) != nil` + * + * @param c1 the first constructor + * @param c2 the second constructor + */ + def injectivity(c1: Constructor[N], c2: Constructor[N]) = + val injectivityLemma = underlying.injectivity(c1.underlying, c2.underlying) + THM(injectivityLemma.statement, s"${c1.name}-${c2.name} injectivity", line.value, file.value, Theorem) { + have(injectivityLemma) + } + + /** + * Type variables appearing in the signature of this ADT + */ + val typeVariables: Variable ** N = underlying.typeVariables + + /** + * Instantiate the type variables of this ADT with given types. + * Checks the arity at runtime. + * + * @param args the types to instantiate the type variables with + */ + def applyUnsafe(args: Term ** N): Term = underlying.term(args.toSeq) + + /** + * Instantiate the type variables of this ADT with given types. + * Checks the arity at runtime. + * + * @param args the types to instantiate the type variables with + */ + def applySeq(args: Seq[Term]): Term = underlying.term(args) + + /** + * Instantiate the type variables of this ADT with given types. + * Checks the arity at runtime. + * + * TODO: wait Scala 3.4.2 to remove this method and extend Term ** N |-> Term instead + * + * @param args the types to instantiate the type variables with + */ + def apply(args: Term*): Term = underlying.term(args) +} + +private object ADT { + /** + * Global map from object identifiers to ADTs + */ + private val identifiersToADT: scala.collection.mutable.Map[Identifier, ADT[?]] = scala.collection.mutable.Map.empty + + /** + * Checks if a label is an ADT, and returns it if it is the case. + * + * @param l the label to check + */ + def unapply(l: Label[?]): Option[ADT[?]] = getADT(l.id) + + /** + * Checks if a term is an instance of an ADT and if it is the case, returns + * the appropriate instances of the type variables. + * + * @param term the term to check + */ + def unapply(obj: Term): Option[(ADT[?], Seq[Term])] = + obj match + case l: Label[?] => + val lwidened: Label[?] = l + unapply(lwidened).map((_, Seq.empty)) + case AppliedFunctional(l, args) => unapply(l).map((_, args)) + case _ => None + + /** + * Checks if a class is an instance of an ADT and if it is the case, returns + * the appropriate instances of the type variables. + * + * @param c the class to check + */ + def unapply(c: Class): Option[(ADT[?], Seq[Term])] = + c match + case t: Term => unapply(t) + case _ => None + + /** + * Returns the ADT associated with an identifier. + * + * @param id the identifier of the ADT + */ + def getADT(id: Identifier): Option[ADT[?]] = identifiersToADT.get(id) +} + +/** + * Type theoretic function over algebraic data types. Its definition is the direct sum of the definitions of its constructors. + * Comes with introduction and elimination rules. + * + * @constructor gives a type theoretic interpretation to a set theoretic function over an ADT + * @tparam N the number of type variables appearing in the definition of this function's domain + * @param line the line at which this ADT is defined. Usually fetched automatically by the compiler. + * Used for error reporting + * @param file the file in which this ADT is defined. Usually fetched automatically by the compiler. + * Used for error reporting + * @param underlying the underlying set theoretic function + * @param adt the domain of this function + */ +private class ADTFunction[N <: Arity](using line: sourcecode.Line, file: sourcecode.File)( + private val underlying: SemanticFunction[N], + private val adt: ADT[N] +) extends TypedConstantFunctional[N]( + underlying.fullName, + underlying.typeArity, + FunctionalClass(Seq.fill(underlying.typeArity)(any), underlying.typeVariablesSeq, underlying.typ, underlying.typeArity), + underlying.intro + ) { + + /** + * Name of the function + * + * e.g. list/length + */ + val name = underlying.fullName + + /** + * Theorem --- Elimination rules + * + * `f * (c * x1 * ... * xn) = case(c, x1, ..., xn)` + * + * That is, when this function is applied to a constructor, it returns the corresponding case. + */ + val elim: Map[Constructor[N], THM] = adt.constructors + .map(c => + ( + c, + THM(underlying.shortDefinition(c.underlying).statement, s"${name} elimination rule: ${c.name} case", line.value, file.value, Theorem) { + have(underlying.shortDefinition(c.underlying)) + } + ) + ) + .toMap + + /** + * Alias for [[this.elim]] + */ + val shortDefinition: Map[Constructor[N], THM] = elim + + /** + * Theorem --- Introduction rule + * + * `∀X1, ..., Xn. f(X1, ..., Xn) : ADT(X1, ..., Xn) -> T` + * + * where `f` is this function, `ADT` the ADT it takes argument and `T` its return type. + */ + val intro: THM = + THM(underlying.intro.statement, s"${name} introduction rule", line.value, file.value, Theorem) { + have(underlying.intro) + } + + /** + * Type variables in the signature of the function + */ + val typeVariables: Variable ** N = underlying.typeVariables +} diff --git a/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Untyped.scala b/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Untyped.scala new file mode 100644 index 000000000..61dd75a7e --- /dev/null +++ b/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/Untyped.scala @@ -0,0 +1,1752 @@ +/** + * This file implements tactics to generate polymorphic set theoretic inductive algebraic data types (or ADT) and prove properties about them. + * An algebraic data type is the least set closed under introduction rules, also known as constructors. + * A constructor takes arguments as input that can either belong to other types (non inductive arguments) + * or to the ADT itself (inductive arguments). + * + * An example of algebraic data type is the type of singly linked lists: + * + * list ::= nil() | cons(head: T, tail: list) + */ + +package lisa.maths.settheory.types.adt + +import lisa.maths.settheory.SetTheory.{*, given} +import Helpers.* +import Helpers.{/\, \/, ===} +import ADTDefinitions.* +import ADTHelperTheorems as ADTThm +import ADTThm.{N, pair, pairExtensionality} +import lisa.maths.settheory.types.TypeLib.{ |=>} +import lisa.maths.settheory.types.TypeSystem.{ :: } +import lisa.maths.Quantifiers.{universalEquivalenceDistribution} +import lisa.fol.FOL.Variable + +/** + * Helpers for constructors + */ +private object Constructors { + + /** + * Global counter used to uniquely identify constructors and thereby avoid structural subtyping. + */ + var tagCounter = 0 +} + +/** + * Syntactic set theoretical interpretation of a constructor for an algebraic data type. + * In set theory, a constructor is a tuple containing the arguments it has been applied to, in addition to a tag + * uniquely identifying it. + * + * E.g. `cons(1, nil())` is represented as `(tagcons, (1, ((tagnil, ∅), ∅)))` + * + * Constructors injectivity is proved within this class. + * + * @constructor creates a new constructor out of a user specification + * @param specification types that the constructor takes as arguments + * @param variables1 variables used to represent the arguments of the constructor + * @param variables2 alternative set of variables to avoid capture issues + */ +private class SyntacticConstructor( + val specification: Seq[ConstructorArgument], + val variables1: Seq[Variable], + val variables2: Seq[Variable], + ) { + + /** + * Unique identifier of this constructor + */ + val tag: Int = Constructors.tagCounter + Constructors.tagCounter = Constructors.tagCounter + 1 + + /** + * Term representation of the tag of this constructor + */ + val tagTerm: Term = toTerm(tag) + + /** + * Sequence of variables used to represent the arguments of the constructor + */ + val variables: Seq[Variable] = variables1 + + /** + * Number of arguments that this constructor takes + */ + val arity: Int = specification.length + + /** + * Sequence of variables of the constructor with their respective domains. + */ + val signature1: Seq[(Variable, ConstructorArgument)] = variables1.zip(specification) + + /** + * Alternative sequence of variables of the constructor with their respective domains. + */ + val signature2: Seq[(Variable, ConstructorArgument)] = variables2.zip(specification) + + /** + * Sequence of variables of the constructor with their respective domains. + */ + val signature: Seq[(Variable, ConstructorArgument)] = signature1 + + /** + * Internally, an instance of this constructor is represented as a list. + * The first element of this list is the tag of this constructor. + * The following elements are its arguments. We represent lists as chained + * pairs followed by the empty set. + * + * e.g. cons(1, nil()) --> (tagcons, (1, ((tagnil, ∅), ∅))) + * + * @param args the arguments of this instance of the constructor + */ + def term(args: Seq[Term]): Term = pair(tagTerm, subterm(args)) + + /** + * Internal representation of an instance of this constructor in which arguments are schematic variables. + */ + val term1: Term = term(variables1) + + /** + * Internal representation of an instance of this constructor in which arguments are an alternative set of schematic variables. + */ + val term2: Term = term(variables2) + + /** + * Internal representation of an instance of this constructor in which arguments are schematic variables. + */ + val term: Term = term1 + + /** + * Internal representation of an instance of this constructor without the tag + * + * @param args the arguments of this instance of the constructor + * + * @see [[this.term]] + */ + def subterm(args: Seq[Term]): Term = args.foldRight[Term](emptySet)(pair(_, _)) + + /** + * Internal representation of an instance of this constructor without the tag, in which arguments are schematic variables. + */ + val subterm1: Term = subterm(variables1) + + /** + * Internal representation of an instance of this constructor without the tag, in which arguments are an alternative set + * of schematic variables. + */ + val subterm2: Term = subterm(variables2) + + /** + * Internal representation of an instance of this constructor without the tag, in which arguments are schematic variables. + */ + val subterm: Term = subterm1 + + /** + * Theorem --- Injectivity of constructors. + * + * Two instances of this constructor are equal if and only if all of their arguments are pairwise equal + * + * e.g. cons(head1, tail1) === cons(head2, tail2) <=> head1 === head2 /\ tail1 === tail2 + */ + lazy val injectivity = + if arity == 0 then + Lemma(term1 === term2) { + have(thesis) by RightRefl + } + else + Lemma((term1 === term2) <=> (variables1 === variables2)) { + + // STEP 1: Get rid of the tag using pair extensionality + have((term1 === term2) <=> (subterm1 === subterm2)) by Restate.from(pairExtensionality of (a := tagTerm, b := subterm1, c := tagTerm, d := subterm2)) + + // STEP 2: Repeat pair extensionality until all variables have been pulled out of the term + variables1 + .zip(variables2) + .foldLeft(Seq.empty[Variable], variables1, Seq.empty[Variable], variables2, lastStep)((acc, v) => + + // pulledVars1 are the variables that have been pulled out of the left term + // remainingVars1 are the variables that are still in the left term + // pulledVars2 are the variables that have been pulled out of the right term + // remainingVars2 are the variables that are still in the right term + val (pulledVars1, remainingVars1, pulledVars2, remainingVars2, previousFact) = acc + + // v1 and v2 are the variables that are being pulled out + val (v1, v2) = v + + val updatedPulledVars1 = pulledVars1 :+ v1 + val updatedPulledVars2 = pulledVars2 :+ v2 + val updatedRemainingVars1 = remainingVars1.tail + val updatedRemainingVars2 = remainingVars2.tail + + val subsubterm1 = subterm(updatedRemainingVars1) + val subsubterm2 = subterm(updatedRemainingVars2) + + have( + (pair(v1, subsubterm1) === pair(v2, subsubterm2)) <=> + ((v1 === v2) /\ (subsubterm1 === subsubterm2)) + ) by Restate.from(pairExtensionality of (a := v1, b := subsubterm1, c := v2, d := subsubterm2)) + have( + ((pulledVars1 === pulledVars2) /\ (pair(v1, subsubterm1) === pair(v2, subsubterm2))) <=> + ((pulledVars1 === pulledVars2) /\ (v1 === v2) /\ (subsubterm1 === subsubterm2)) + ) by Cut( + lastStep, + ADTThm.rightAndEquivalence of (p := pulledVars1 === pulledVars2, p1 := pair(v1, subsubterm1) === pair(v2, subsubterm2), p2 := (v1 === v2) /\ (subsubterm1 === subsubterm2)) + ) + val newFact = have( + (term1 === term2) <=> + ((updatedPulledVars1 === updatedPulledVars2) /\ (subsubterm1 === subsubterm2)) + ) by Apply(ADTThm.equivalenceRewriting).on(lastStep, previousFact) + + (updatedPulledVars1, updatedRemainingVars1, updatedPulledVars2, updatedRemainingVars2, newFact) + ) + } + +} + +/** + * Syntactic set theoretical interpretation of an algebraic data type. That is the least set closed under [[SyntacticConstructor]]. + * + * E.g. list is the smallest set containing nil and closed under the syntactic operation cons. + * + * Injectivity between different constructors, introduction rules and structural induction are proved within this class. + * + * @constructor creates a new algebraic data type out of a user specification. + * @param line the line at which the ADT is defined. Usually fetched automatically by the compiler. + * Used for error reporting + * @param file the file in which the ADT is defined. Usually fetched automatically by the compiler. + * Used for error reporting + * @param name the name of the ADT + * @param constructors constructors of the ADT + * @param typeVariables type variables used in the definition of this ADT + */ +private class SyntacticADT[N <: Arity](using line: sourcecode.Line, file: sourcecode.File)( + val name: String, + val constructors: Seq[SyntacticConstructor], + val typeVariables: Variable ** N, + ) { + + /** + * Sequence of type variables used in the definition of this ADT + */ + val typeVariablesSeq: Seq[Variable] = typeVariables.toSeq + + /** + * Number of type variables used in the definition of this ADT + */ + val typeArity: N = typeVariablesSeq.length.asInstanceOf[N] + + // *************** + // * INJECTIVITY * + // *************** + + /** + * Theorem --- Injectivity of constructors. + * + * Two instances of different construcors are always different. + * + * e.g. Nil != Cons(head, tail) + */ + def injectivity(c1: SyntacticConstructor, c2: SyntacticConstructor) = + require(c1.tag != c2.tag, "The given constructors must be different.") + + Lemma(!(c1.term1 === c2.term2)) { + + // STEP 0: Caching + val tagTerm1: Term = c1.tagTerm + val tagTerm2: Term = c2.tagTerm + + // STEP 1: Prove that the tags are different + val diffTag = have(!(tagTerm1 === tagTerm2)) subproof { + + // STEP 1.1: Order the tags + val minTag: Int = Math.min(c1.tag, c2.tag) + val maxTag: Int = Math.max(c1.tag, c2.tag) + + val start = have(tagTerm1 === tagTerm2 |- toTerm(maxTag) === toTerm(minTag)) by Restate + + // STEP 1.2: Apply successor injectivity to both tags until one becomes 0 + (1 to minTag).foldLeft(start)((fact, i) => + val midMaxTag = toTerm(maxTag - i) + val midMinTag = toTerm(minTag - i) + have(successor(midMaxTag) === successor(midMinTag) |- midMaxTag === midMinTag) by Cut( + ADTThm.successorInjectivity of (n := midMaxTag, m := midMinTag), + ADTThm.equivalenceApply of (p1 := successor(midMaxTag) === successor(midMinTag), p2 := midMaxTag === midMinTag) + ) + have(tagTerm1 === tagTerm2 |- midMaxTag === midMinTag) by Cut(fact, lastStep) + ) + + val chainInjectivity = thenHave(!(toTerm(maxTag - minTag) === emptySet) |- !(tagTerm1 === tagTerm2)) by Restate + + // STEP 1.3: Conclude using the fact that 0 is not the successor of any number + have(!(toTerm(maxTag - minTag) === emptySet)) by Exact(ADTThm.zeroIsNotSucc) + have(thesis) by Cut(lastStep, chainInjectivity) + } + + // STEP 2: Prove that the terms are different if the tags are different + have(c1.term1 === c2.term2 |- (tagTerm1 === tagTerm2) /\ (c1.subterm1 === c2.subterm2)) by Apply(ADTThm.equivalenceRevApply).on( + pairExtensionality of (a := tagTerm1, b := c1.subterm1, c := tagTerm2, d := c2.subterm2) + ) + thenHave(!(tagTerm1 === tagTerm2) |- !(c1.term1 === c2.term2)) by Weakening + + // STEP 3: Conclude + have(!(c1.term1 === c2.term2)) by Cut(diffTag, lastStep) + } + + // ************************* + // * INTRODUCTION FUNCTION * + // ************************* + + /** + * Formula describing whether the variables of a constructor belongs to their respective domain or s when they are self-referencing. + * + * @param c The considered constructor + * @param s The set of elements in which self-referencing variables of the constructor are. + */ + private def constructorVarsInDomain(c: SyntacticConstructor, s: Term): Formula = wellTypedFormula(c.signature)(s) + + /** + * Formula describing whether an element x is an instance of a specific constructor. + * + * @param c The constructor we want to check if x is an instance of + * @param x The element we want to check if it is an instance of c + * @param s The set of elements in which self-referencing arguments of the constructor are. + */ + private def isConstructor(c: SyntacticConstructor, x: Term, s: Term): Formula = + existsSeq(c.variables2, wellTypedFormula(c.signature2)(s) /\ (x === c.term2)) + + /** + * Formula describing whether an element x is an instance of one of this ADT's constructors. + * + * @param x The element we want to check if it is an instance of some constructor. + * @param s The set of elements in which self-referencing arguments of the constructor are. + */ + private def isConstructor(x: Term, s: Term): Formula = \/(constructors.map(c => isConstructor(c, x, s))) + + /** + * The introduction (class) function applies this ADT's constructors to the argument to given to it. + * It then adds to elements of the resulting set to the one given in argument. For example, if all arguments of the + * constructors were self-referencing we would have: + * + * introductionFunction(s) = {y | y = c(x1, ..., xn) for some c ∈ constructors and x1, ..., xn ∈ s} ∪ s + * + * In order to avoid introducing a new symbol in the theory, we describe this function with a predicate. + * + * @param s the argument of this function, i.e. set of elements on which the constructors are applied + * @param y the element we want to check if it is in the image of s under the introduction function. + * + * @return a formula describing whether y ∈ introductionFunction(s) + * + * @note The existence of the image of the introduction function is guaranteed by the union and replacement axioms. Moreover, it is not necessary to compute the union with s. It however simplifies further proofs. See [[this.heightSuccessorStrong]] for a proof of the equivalence of the two definitions. + */ + private def isInIntroductionFunctionImage(s: Term)(y: Term): Formula = isConstructor(y, s) \/ in(y, s) + + + /** + * Lemma --- The introduction function is monotonic with respect to set inclusion. + * + * `s ⊆ t |- introductionFunction(s) ⊆ introductionFunction(t)` + */ + private val introductionFunctionMononotic = Lemma(subset(s, t) |- isInIntroductionFunctionImage(s)(x) ==> isInIntroductionFunctionImage(t)(x)) { + // In the rest of the proof we assume that s ⊆ t + + // STEP 0: Caching predicates that are often used + val subsetST = subset(s, t) + val isConstructorXS = isConstructor(x, s) + val isConstructorXT = isConstructor(x, t) + + // STEP 1: Prove x ∈ s implies x ∈ t + have(subsetST |- forall(z, in(z, s) ==> in(z, t))) by Apply(ADTThm.equivalenceApply of (p1 := subsetST)).on(subsetAxiom.asInstanceOf) + val subsetElimination = thenHave(subsetST |- in(z, s) ==> in(z, t)) by InstantiateForall(z) + + // STEP 2: For each constructor, prove that if x is an instance of that constructor with self referencing arguments in s + // then it is also an instance of some constructor with self referencing arguments in t + val isConstructorXSImpliesT = + for c <- constructors yield + // STEP 2.0: Caching predicates that are often used + // TODO change identifier + val labelEq = x === c.term2 + val isConstructorCXS = isConstructor(c, x, s) + val isConstructorCXT = isConstructor(c, x, t) + val varsWellTypedS = wellTypedFormula(c.signature2)(s) + val varsWellTypedT = wellTypedFormula(c.signature2)(t) + + if c.arity == 0 then have((subsetST, isConstructorCXS) |- isConstructorXT) by Restate + else + // STEP 2.1: Prove that we can expand the domain of the (quantified) variables of the constructor + val andSeq = + for (v, ty) <- c.signature2 yield have((subsetST, varsWellTypedS) |- in(v, ty.getOrElse(t))) by Weakening(subsetElimination of (z := v)) + val expandingDomain = have((subsetST, varsWellTypedS) |- varsWellTypedT) by RightAnd(andSeq: _*) + val weakeningLabelEq = have(labelEq |- labelEq) by Hypothesis + have((subsetST, varsWellTypedS, labelEq) |- varsWellTypedT /\ labelEq) by RightAnd(expandingDomain, weakeningLabelEq) + + // STEP 2.2: Prove that x stays an instance of this constructor if we expand the domain of the variables + thenHave((subsetST, varsWellTypedS, labelEq) |- isConstructorCXT) by QuantifiersIntro(c.variables2) + thenHave((subsetST, varsWellTypedS /\ labelEq) |- isConstructorCXT) by LeftAnd + thenHave((subsetST, isConstructorCXS) |- isConstructorCXT) by QuantifiersIntro(c.variables2) + + // STEP 2.3: Weaken the conclusion to some constructor instead of a specific one + thenHave((subsetST, isConstructorCXS) |- isConstructorXT) by Weakening + + // STEP 3: Prove that this holds for any constructor + // ? Steps 2 and 3 can be merged and optimized through the repeated use of an external theorem like [[ADTHelperTheorems.unionPreimageMonotonic]] + if constructors.isEmpty then have((subsetST, isConstructorXS) |- isConstructorXT) by Restate + else have((subsetST, isConstructorXS) |- isConstructorXT) by LeftOr(isConstructorXSImpliesT: _*) + + // STEP 4: Prove the thesis by showing that making the union with the function argument does not change the monotonicity + thenHave(subsetST |- isConstructorXS ==> isConstructorXT) by RightImplies + have(thesis) by Cut(lastStep, ADTThm.unionPreimageMonotonic of (P := lambda(s, isConstructorXS))) + } + + + /** + * Lemma --- Every constructor is in the image of the introduction function. + * + * `For every c ∈ constructors, xi ∈ s, ..., xj ∈ s |- c(x1, ..., xn) ∈ introductionFunction(s)` + */ + private val constructorIsInIntroductionFunction = constructors + .map(c => + // Caching + val constructorVarsInDomainCS = constructorVarsInDomain(c, s) + + c -> Lemma(constructorVarsInDomainCS |- isInIntroductionFunctionImage(s)(c.term)) { + + have(constructorVarsInDomainCS |- constructorVarsInDomainCS /\ (c.term === c.term)) by Restate + + // Replace each variable on the LHS of the equality by a quantified variable and then introduce an existential quantifier + (c.variables2).foldRight((c.variables1, List[Variable]()))((v, acc) => + + // At each step remove a variable and add a quantified one + val oldVariables = acc._1.init + val newVariables = v :: acc._2 + val vars = oldVariables ++ newVariables + + thenHave(constructorVarsInDomainCS |- existsSeq(newVariables, wellTypedFormula(vars.zip(c.specification))(s) /\ (c.term(vars) === c.term))) by RightExists + + (oldVariables, newVariables) + ) + + thenHave(constructorVarsInDomainCS |- isInIntroductionFunctionImage(s)(c.term)) by Weakening + } + ) + .toMap + + // ********************************** + // * EXTENDED INTRODUCTION FUNCTION * + // ********************************** + + /** + * The extended introduction (class) function takes a function f as an argument instead of set. + * - If f is not empty, it calls the introduction function on the union of the ranges of the function. Since f will + * always be cumulative by assumption, this is equivalent as passing as argument the broadest set among the ranges of f. + * - If the function is empty, it returns the empty set. + * + * This class function is in a suited format to be used within the transfinite recursion theorem, which will be called to + * construct the height function. + * + * @see [[this.heightFunctionUniqueness]] + * + * @param f the function given as argument to the extended introduction function + * @param x the element we want to check if it is in the image of f under the extended introduction function + * @return a formula describing whether x ∈ extendedIntroductionFunction(f) + */ + private def isInExtendedIntroductionFunctionImage(f: Term)(x: Term): Formula = !(f === emptySet) /\ isInIntroductionFunctionImage(unionRange(f))(x) + + /** + * Lemma --- The extended introduction function is monotonic with respect to set inclusion. + * + * `f ⊆ g |- extendedIntroductionFunction(f) ⊆ extendedIntroductionFunction(g)` + */ + private val extendedIntroductionFunctionMonotonic = Lemma(subset(f, g) |- isInExtendedIntroductionFunctionImage(f)(x) ==> isInExtendedIntroductionFunctionImage(g)(x)) { + + // STEP 0: Caching + val introFunUnionRangeF = isInIntroductionFunctionImage(unionRange(f))(x) + val introFunUnionRangeG = isInIntroductionFunctionImage(unionRange(g))(x) + + // STEP 1: Instantiate monotonicity of the introduction function for the union of the ranges of f and g + have(subset(f, g) |- introFunUnionRangeF ==> introFunUnionRangeG) by Cut( + ADTThm.unionRangeMonotonic, + introductionFunctionMononotic of (s := unionRange(f), t := unionRange(g)) + ) + val left = thenHave((subset(f, g), introFunUnionRangeF) |- introFunUnionRangeG) by Restate + + // STEP 2: Conclude by applying the conjuction on both sides + have((subset(f, g), !(f === emptySet), introFunUnionRangeF) |- isInExtendedIntroductionFunctionImage(g)(x)) by RightAnd(left, ADTThm.subsetNotEmpty of (x := f, y := g)) + } + + // ******************* + // * HEIGHT FUNCTION * + // ******************* + + /** + * The height function assigns to each natural number the set of elements of the ADT of that height or below. + * The set of terms with height 0 is empty. Non inductive constructors have height one. + * The height of an instance of an inductive constructor is the maximum height of its arguments plus one. + * The height function is guaranteed to exists and is unique. + * + * @see [[this.heightFunctionUniqueness]] + * + * @param g the function we want to know if it is the height function + * + * @return a formula that is true if and only if g is the height function + */ + private def isTheHeightFunction(h: Term): Formula = + functional(h) /\ (relationDomain(h) === N) /\ forall(n, in(n, N) ==> forall(x, in(x, app(h, n)) <=> isInExtendedIntroductionFunctionImage(restrictedFunction(h, n))(x))) + + // Caching + private val fIsTheHeightFunction: Formula = isTheHeightFunction(f) + private val hIsTheHeightFunction: Formula = isTheHeightFunction(h) + + /** + * Lemma --- There exists a unique height function for this ADT. + * + * `∃!h. h = height` + * + * TODO: Prove this using transfinite recursion + */ + private val heightFunUniqueness = Axiom(existsOne(h, hIsTheHeightFunction)) + + /** + * Lemma --- The height function exists. + * + * `∃h. h = height` + */ + private val heightFunctionExistence = Lemma(exists(h, hIsTheHeightFunction)) { + have(thesis) by Apply(lisa.maths.Quantifiers.existsOneImpliesExists of (P := lambda(h, hIsTheHeightFunction))).on(heightFunUniqueness.asInstanceOf) + } + + /** + * Lemma --- If two functions are the height function then they are the same. + * + * `f = height /\ h = height => f = h` + */ + private val heightFunctionUniqueness2 = Lemma((fIsTheHeightFunction, hIsTheHeightFunction) |- f === h) { + have(thesis) by Cut(heightFunUniqueness, ADTThm.existsOneUniqueness of (P := lambda(h, hIsTheHeightFunction), x := f, y := h)) + } + + /** + * Lemma --- The height function is not empty. + * + * `height ≠ ∅` + */ + private val heightFunctionNonEmpty = Lemma(hIsTheHeightFunction |- !(h === emptySet)) { + // The proof goes by contradiction. If the height function is empty then its domain is empty as well. + // This would imply that the set of natural numbers is empty, which is a contradiction. + have(N === emptySet |- ()) by Restate.from(ADTThm.natNotEmpty) + thenHave((relationDomain(h) === emptySet, relationDomain(h) === N, relationDomain(h) === relationDomain(h)) |- ()) by LeftSubstEq.withParametersSimple( + List((relationDomain(h), emptySet), (relationDomain(h), N)), + lambda((x, y), y === x) + ) + thenHave((relationDomain(h) === N, relationDomain(h) === relationDomain(h)) |- !(relationDomain(h) === emptySet)) by RightNot + have(thesis) by Apply(ADTThm.nonEmptyDomain).on(lastStep) + } + + /** + * Lemma --- The set of elements of height n or below is the image of the extended introduction function under the height + * function restricted to n (consequence of transfinite recursion). + * + * `height(n) = extendedIntroductionFunction(height | n)` + */ + private val heightApplication = Lemma((hIsTheHeightFunction, in(n, N)) |- in(x, app(h, n)) <=> isInExtendedIntroductionFunctionImage(restrictedFunction(h, n))(x)) { + + // Caching + val extendedIntroFunRestrictedFunM = isInExtendedIntroductionFunctionImage(restrictedFunction(h, n))(x) + val heightFunApplicationDef = forall(n, in(n, N) ==> forall(x, in(x, app(h, n)) <=> extendedIntroFunRestrictedFunM)) + + // Nothing fancy, just instantiations and restates + have(heightFunApplicationDef |- heightFunApplicationDef) by Hypothesis + thenHave(heightFunApplicationDef |- in(n, N) ==> forall(x, in(x, app(h, n)) <=> extendedIntroFunRestrictedFunM)) by InstantiateForall(n) + thenHave((heightFunApplicationDef, in(n, N)) |- forall(x, in(x, app(h, n)) <=> extendedIntroFunRestrictedFunM)) by Restate + thenHave((heightFunApplicationDef, in(n, N)) |- in(x, app(h, n)) <=> extendedIntroFunRestrictedFunM) by InstantiateForall(x) + thenHave(thesis) by Weakening + } + + /** + * Lemma --- The height function is monotonic + * + * `n <= m => height(n) ⊆ height(m)` + * + * TODO: Try to pull out + */ + private val heightMonotonic = Lemma((hIsTheHeightFunction, in(n, N), subset(m, n)) |- subset(app(h, m), app(h, n))) { + + // STEP 0: Caching + val extendedIntroFunRestrictedFunM = isInExtendedIntroductionFunctionImage(restrictedFunction(h, m))(x) + + // STEP 1: Unfold the definition of height(m) + have((hIsTheHeightFunction, in(n, N), subset(m, n)) |- in(x, app(h, m)) <=> extendedIntroFunRestrictedFunM) by Apply(heightApplication).on(ADTThm.subsetIsNat.asInstanceOf) + val unfoldHeightApplicationM = have((hIsTheHeightFunction, in(n, N), subset(m, n), in(x, app(h, m))) |- extendedIntroFunRestrictedFunM) by Cut( + lastStep, + ADTThm.equivalenceRevApply of (p1 := in(x, app(h, m)), p2 := extendedIntroFunRestrictedFunM) + ) + + // STEP 2: Use the monotonicity of the extended introduction function + have(subset(m, n) |- extendedIntroFunRestrictedFunM ==> isInExtendedIntroductionFunctionImage(restrictedFunction(h, n))(x)) by Cut( + ADTThm.restrictedFunctionDomainMonotonic of (x := m, y := n, f := h), + extendedIntroductionFunctionMonotonic of (f := restrictedFunction(h, m), g := restrictedFunction(h, n)) + ) + have((hIsTheHeightFunction, in(n, N), subset(m, n), extendedIntroFunRestrictedFunM) |- in(x, app(h, n))) by Apply(ADTThm.equivalenceRevApply).on(lastStep, heightApplication.asInstanceOf) + + // STEP 3: Fold the definition of subset + have((hIsTheHeightFunction, in(n, N), subset(m, n), in(x, app(h, m))) |- in(x, app(h, n))) by Cut(unfoldHeightApplicationM, lastStep) + thenHave((hIsTheHeightFunction, in(n, N), subset(m, n)) |- in(x, app(h, m)) ==> in(x, app(h, n))) by RightImplies + thenHave((hIsTheHeightFunction, in(n, N), subset(m, n)) |- forall(x, in(x, app(h, m)) ==> in(x, app(h, n)))) by RightForall + have(thesis) by Apply(ADTThm.equivalenceRevApply).on(lastStep, subsetAxiom.asInstanceOf) + } + + /** + * Lemma --- There is no element of height 0 in the ADT. + * + * `!∃x ∈ adt. height(x) = 0` + */ + private val heightZero = Lemma(hIsTheHeightFunction |- !in(x, app(h, emptySet))) { + + // This is due to the fact that the extended introduction function is the empty set when the function is empty + // (which happens when the height is set to 0). + have(hIsTheHeightFunction |- in(x, app(h, emptySet)) <=> isInExtendedIntroductionFunctionImage(restrictedFunction(h, emptySet))(x)) by Cut(ADTThm.zeroIsNat, heightApplication of (n := emptySet)) + thenHave((restrictedFunction(h, emptySet) === emptySet, hIsTheHeightFunction) |- !in(x, app(h, emptySet))) by + RightSubstEq.withParametersSimple( + List((restrictedFunction(h, emptySet), emptySet)), + lambda(s, in(x, app(h, emptySet)) <=> isInExtendedIntroductionFunctionImage(s)(x)) + ) + have(thesis) by Cut(ADTThm.restrictedFunctionEmptyDomain, lastStep) + } + + /** + * Lemma --- The set of elements of height n + 1 is the set of elements of height n to which the introduction function is applied. + * + * `height(n + 1) = introductionFunction(height(n))` + */ + private val heightSuccessorWeak = Lemma((hIsTheHeightFunction, in(n, N)) |- in(x, app(h, successor(n))) <=> isInIntroductionFunctionImage(app(h, n))(x)) { + + // STEP 1: Prove that the restriction of height to n + 1 is not empty + val restrHeightNotEmpty: Formula = !(restrictedFunction(h, successor(n)) === emptySet) + have(!(h === emptySet) |- restrHeightNotEmpty) by Cut(ADTThm.zeroIsNotSucc, ADTThm.restrictedFunctionNotEmpty of (d := successor(n))) + val restrHeightNotEmptyLemma = have(hIsTheHeightFunction |- restrHeightNotEmpty) by Cut(heightFunctionNonEmpty, lastStep) + + // STEP 2: Use the fact that if the function is cumulative then ∪ range(height | n + 1) = height(n) to conclude the proof + have((hIsTheHeightFunction, in(n, N)) |- subset(m, n) ==> subset(app(h, m), app(h, n))) by RightImplies(heightMonotonic) + thenHave((hIsTheHeightFunction, in(n, N)) |- forall(m, subset(m, n) ==> subset(app(h, m), app(h, n)))) by RightForall + val unionRangeRestr = have((hIsTheHeightFunction, in(n, N)) |- unionRange(restrictedFunction(h, successor(n))) === app(h, n)) by Apply(ADTThm.unionRangeCumulativeRestrictedFunction).on(lastStep) + + have((hIsTheHeightFunction, in(n, N)) |- in(x, app(h, successor(n))) <=> isInExtendedIntroductionFunctionImage(restrictedFunction(h, successor(n)))(x)) by Apply(heightApplication).on( + ADTThm.equivalenceApply of (p1 := in(n, N)), + ADTThm.successorIsNat.asInstanceOf + ) + + thenHave( + (hIsTheHeightFunction, in(n, N), unionRange(restrictedFunction(h, successor(n))) === app(h, n)) |- + in(x, app(h, successor(n))) <=> restrHeightNotEmpty /\ isInIntroductionFunctionImage(app(h, n))(x) + ) by + RightSubstEq.withParametersSimple( + List((unionRange(restrictedFunction(h, successor(n))), app(h, n))), + lambda(s, in(x, app(h, successor(n))) <=> (restrHeightNotEmpty /\ isInIntroductionFunctionImage(s)(x))) + ) + + have((hIsTheHeightFunction, in(n, N)) |- in(x, app(h, successor(n))) <=> restrHeightNotEmpty /\ isInIntroductionFunctionImage(app(h, n))(x)) by Cut(unionRangeRestr, lastStep) + + have((hIsTheHeightFunction, in(n, N), restrHeightNotEmpty) |- in(x, app(h, successor(n))) <=> isInIntroductionFunctionImage(app(h, n))(x)) by Apply(ADTThm.equivalenceAnd of (p2 := restrHeightNotEmpty)) + .on(lastStep) + + have(thesis) by Cut(restrHeightNotEmptyLemma, lastStep) + } + + // ******** + // * TERM * + // ******** + + /** + * Formula describing this ADT's term, i.e. the set of all its instances. + * It equal to the union of all the terms that have a height. + * + * `adt = ∪ height(n) = {x | ∃n ∈ N. x ∈ height(n)}` + * + * @param adt the set chracterizing this ADT + */ + private def termDefinition(adt: Term): Formula = forall(t, in(t, adt) <=> forall(h, hIsTheHeightFunction ==> in(t, unionRange(h)))) + + /** + * Lemma --- There exists a unique set satisfying the definition of this ADT + * + * `∃!z. z = ADT + */ + private val termExistence = Lemma(existsOne(z, termDefinition(z))) { + + // STEP 0: Caching + val termDefinitionRight = forall(h, hIsTheHeightFunction ==> in(t, unionRange(h))) + val inUnionRangeF = in(t, unionRange(f)) + + // STEP 1: Prove that there exists a term satisfying the definition of this ADT. + // Specifically, this term is the union of all the terms with a height. + have(exists(z, termDefinition(z))) subproof { + + // STEP 1.1: Prove the forward implication of the definition, using the uniqueness of the height function + have(inUnionRangeF |- inUnionRangeF) by Hypothesis + thenHave((f === h, inUnionRangeF) |- in(t, unionRange(h))) by RightSubstEq.withParametersSimple( + List((f, h)), + lambda(f, inUnionRangeF) + ) + have((fIsTheHeightFunction, hIsTheHeightFunction, inUnionRangeF) |- in(t, unionRange(h))) by Cut(heightFunctionUniqueness2, lastStep) + thenHave((fIsTheHeightFunction, inUnionRangeF) |- hIsTheHeightFunction ==> in(t, unionRange(h))) by RightImplies + thenHave((fIsTheHeightFunction, inUnionRangeF) |- termDefinitionRight) by RightForall + val forward = thenHave(fIsTheHeightFunction |- inUnionRangeF ==> termDefinitionRight) by RightImplies + + // STEP 1.2: Prove the backward implication of the definition + have(termDefinitionRight |- termDefinitionRight) by Hypothesis + thenHave(termDefinitionRight |- fIsTheHeightFunction ==> inUnionRangeF) by InstantiateForall(f) + val backward = thenHave(fIsTheHeightFunction |- termDefinitionRight ==> inUnionRangeF) by Restate + + // STEP 1.3: Use the existence of the height function to prove the existence of this ADT + have(fIsTheHeightFunction |- inUnionRangeF <=> termDefinitionRight) by RightIff(forward, backward) + thenHave(fIsTheHeightFunction |- forall(t, inUnionRangeF <=> termDefinitionRight)) by RightForall + + thenHave(fIsTheHeightFunction |- exists(z, forall(t, in(t, z) <=> termDefinitionRight))) by RightExists + thenHave(exists(f, fIsTheHeightFunction) |- exists(z, forall(t, in(t, z) <=> termDefinitionRight))) by LeftExists + have(thesis) by Cut(heightFunctionExistence, lastStep) + } + + // STEP 2: Conclude using the extension by definition + + have(thesis) by Cut(lastStep, uniqueByExtension of (schemPred := lambda(t, termDefinitionRight))) + } + + /** + * Class function defining the ADT. Takes as parameters the type variables of the ADT and return the set of all its instances. + */ + val polymorphicTerm = FunctionDefinition[N](name, line.value, file.value)(typeVariablesSeq, z, termDefinition(z), termExistence).label + + /** + * The set of all instances of the ADT where the type variables are not instantiated (i.e. are kept variable). + */ + val term = polymorphicTerm.applySeq(typeVariablesSeq) + + /** + * Definition of this ADT's term. + */ + private val termDefinition: Formula = termDefinition(term) + + /** + * Lemma --- This ADT satisfies its definition. + * + * `adt = ∪ height(n)` + */ + private val termSatisfiesDefinition = Lemma(termDefinition) { + have(thesis) by InstantiateForall(term)(polymorphicTerm.definition) + } + + // ************************* + // * TYPING / INTRODUCTION * + // ************************* + + /** + * Lemma --- Every element of this ADT has a height. Conversely, if an element has a height, it is in this ADT. + * + * ` x ∈ ADT <=> ∃n ∈ N. x ∈ height(n)` + * + * TODO: Split into two lemmas + */ + private val termHasHeight = Lemma(hIsTheHeightFunction |- in(x, term) <=> ∃(n, in(n, N) /\ in(x, app(h, n)))) { + + // STEP 0 : Instantiate the definition of this ADT and recover the forward and backward implications + val termDefinition = have(in(x, term) <=> forall(h, hIsTheHeightFunction ==> in(x, unionRange(h)))) by InstantiateForall(x)(termSatisfiesDefinition) + val termDefinitionForward = have(in(x, term) |- forall(h, hIsTheHeightFunction ==> in(x, unionRange(h)))) by Cut( + termDefinition, + ADTThm.equivalenceApply of (p1 := in(x, term), p2 := forall(h, hIsTheHeightFunction ==> in(x, unionRange(h)))) + ) + val termDefinitionBackward = have(forall(h, hIsTheHeightFunction ==> in(x, unionRange(h))) |- in(x, term)) by Cut( + termDefinition, + ADTThm.equivalenceRevApply of (p2 := in(x, term), p1 := forall(h, hIsTheHeightFunction ==> in(x, unionRange(h)))) + ) + + // STEP 1 : Prove that an element is in this ADT if and only if it is in one of the images of the height function. + have(hIsTheHeightFunction |- in(x, term) <=> in(x, unionRange(h))) subproof { + + // STEP 1.1 : Forward implication + have(forall(h, hIsTheHeightFunction ==> in(x, unionRange(h))) |- forall(h, hIsTheHeightFunction ==> in(x, unionRange(h)))) by Hypothesis + thenHave(forall(h, hIsTheHeightFunction ==> in(x, unionRange(h))) |- hIsTheHeightFunction ==> in(x, unionRange(h))) by InstantiateForall(h) + thenHave((forall(h, hIsTheHeightFunction ==> in(x, unionRange(h))), hIsTheHeightFunction) |- in(x, unionRange(h))) by Restate + + val forward = have(hIsTheHeightFunction |- in(x, term) ==> in(x, unionRange(h))) by Apply(lastStep).on(termDefinitionForward) + + // STEP 1.2 : Backward implication, follows from uniqueness of the height function + have(in(x, unionRange(h)) |- in(x, unionRange(h))) by Hypothesis + thenHave((f === h, in(x, unionRange(h))) |- in(x, unionRange(f))) by RightSubstEq.withParametersSimple(List((f, h)), lambda(h, in(x, unionRange(h)))) + have((fIsTheHeightFunction, hIsTheHeightFunction, in(x, unionRange(h))) |- in(x, unionRange(f))) by Cut(heightFunctionUniqueness2, lastStep) + thenHave((hIsTheHeightFunction, in(x, unionRange(h))) |- fIsTheHeightFunction ==> in(x, unionRange(f))) by RightImplies + thenHave((hIsTheHeightFunction, in(x, unionRange(h))) |- forall(f, fIsTheHeightFunction ==> in(x, unionRange(f)))) by RightForall + have((hIsTheHeightFunction, in(x, unionRange(h))) |- in(x, term)) by Cut(lastStep, termDefinitionBackward) + val backward = thenHave(hIsTheHeightFunction |- in(x, unionRange(h)) ==> in(x, term)) by RightImplies + + have(thesis) by RightIff(forward, backward) + } + + // STEP 2: Conclude by instantiating the union range membership lemma + have(hIsTheHeightFunction |- in(x, term) <=> ∃(n, in(n, relationDomain(h)) /\ in(x, app(h, n)))) by Apply(ADTThm.equivalenceRewriting).on(ADTThm.unionRangeMembership.asInstanceOf, lastStep) + + thenHave((hIsTheHeightFunction, relationDomain(h) === N) |- in(x, term) <=> ∃(n, in(n, N) /\ in(x, app(h, n)))) by RightSubstEq.withParametersSimple( + List((relationDomain(h), N)), + lambda(z, in(x, term) <=> ∃(n, in(n, z) /\ in(x, app(h, n)))) + ) + } + + /** + * Lemma --- Every element of this ADT has a height. Conversely, if an element has a height, it is in this ADT. + * + * ` xi, ..., xj ∈ ADT <=> ∃n ∈ N. xi, ..., xj ∈ height(n)` + * + * TODO: Work this out + * TODO: Split into two lemmas + */ + private val termsHaveHeight = constructors + .map(c => + c -> Lemma(hIsTheHeightFunction |- (constructorVarsInDomain(c, term) <=> ∃(n, in(n, N) /\ constructorVarsInDomain(c, app(h, n))))) { + + if c.variables.isEmpty then have(thesis) by Weakening(ADTThm.existsNat) + else + + // STEP 1: Backward implication + + val backward = have(hIsTheHeightFunction |- ∃(n, in(n, N) /\ constructorVarsInDomain(c, app(h, n))) ==> constructorVarsInDomain(c, term)) subproof { + val andSeq = for (v, ty) <- c.signature yield ty match + case Self => + val termHasHeightBackward = have((hIsTheHeightFunction, exists(n, in(n, N) /\ in(v, app(h, n)))) |- in(v, term)) by Cut( + termHasHeight of (x := v), + ADTThm.equivalenceRevApply of (p1 := ∃(n, in(n, N) /\ in(v, app(h, n))), p2 := in(v, term)) + ) + + have((in(n, N) /\ in(v, app(h, n))) |- in(n, N) /\ in(v, app(h, n))) by Restate + thenHave((in(n, N) /\ in(v, app(h, n))) |- exists(n, in(n, N) /\ in(v, app(h, n)))) by RightExists + have((hIsTheHeightFunction, in(n, N) /\ in(v, app(h, n))) |- in(v, term)) by Cut(lastStep, termHasHeightBackward) + thenHave((hIsTheHeightFunction, in(n, N) /\ constructorVarsInDomain(c, app(h, n))) |- in(v, term)) by Weakening + case GroundType(t) => + have((hIsTheHeightFunction, in(n, N) /\ constructorVarsInDomain(c, app(h, n))) |- in(v, t)) by Restate + + have((hIsTheHeightFunction, in(n, N) /\ constructorVarsInDomain(c, app(h, n))) |- constructorVarsInDomain(c, term)) by RightAnd(andSeq: _*) + thenHave((hIsTheHeightFunction, exists(n, in(n, N) /\ constructorVarsInDomain(c, app(h, n)))) |- constructorVarsInDomain(c, term)) by LeftExists + } + + // STEP 2: Forward implication + + val forward = have(hIsTheHeightFunction |- constructorVarsInDomain(c, term) ==> ∃(n, in(n, N) /\ constructorVarsInDomain(c, app(h, n)))) subproof { + val nSeq: Seq[Variable] = (0 until c.variables.size).map(i => Variable(s"n$i")) + val max = if c.arity == 0 then emptySet else nSeq.reduce[Term](setUnion(_, _)) + + val maxInN = have(/\(nSeq.map(n => in(n, N))) |- in(max, N)) by Sorry + + val andSeq = for ((v, ty), ni) <- c.signature.zip(nSeq) yield + val niInMax = have(subset(ni, max)) by Sorry + + ty match + case Self => + have((hIsTheHeightFunction, in(max, N), subset(ni, max)) |- subset(app(h, ni), app(h, max))) by Restate.from(heightMonotonic of (m := ni, n := max)) + have((hIsTheHeightFunction, /\(nSeq.map(n => in(n, N)))) |- subset(app(h, ni), app(h, max))) by Sorry // Apply(lastStep).on(Seq(maxInN, niInMax), excluding = nSeq) + have((hIsTheHeightFunction, /\(nSeq.map(n => in(n, N)))) |- forall(z, in(z, app(h, ni)) ==> in(z, app(h, max)))) by Apply(ADTThm.equivalenceApply) + .on(Seq(lastStep, subsetAxiom), excluding = nSeq) + thenHave((hIsTheHeightFunction, /\(nSeq.map(n => in(n, N)))) |- in(v, app(h, ni)) ==> in(v, app(h, max))) by InstantiateForall(v) + thenHave((hIsTheHeightFunction, /\(nSeq.map(n => in(n, N))), in(v, app(h, ni))) |- in(v, app(h, max))) by Restate + case GroundType(t) => + have((/\(nSeq.map(n => in(n, N))), hIsTheHeightFunction, in(v, t)) |- in(v, t)) by Restate + + have((/\(nSeq.map(n => in(n, N))), hIsTheHeightFunction, in(v, ty.getOrElse(app(h, ni)))) |- in(max, N) /\ in(v, ty.getOrElse(app(h, max)))) by RightAnd(maxInN, lastStep) + thenHave(nSeq.map(n => in(n, N) /\ in(v, ty.getOrElse(app(h, n)))).toSet + hIsTheHeightFunction |- in(max, N) /\ in(v, ty.getOrElse(app(h, max)))) by Weakening + thenHave(nSeq.map(n => in(n, N) /\ in(v, ty.getOrElse(app(h, n)))).toSet + hIsTheHeightFunction |- ∃(n, in(n, N) /\ in(v, ty.getOrElse(app(h, n))))) by RightExists + + sorry + } + + // STEP 3: Conclude + have(thesis) by RightIff(forward, backward) + } + ) + .toMap + + /** + * Lemma --- If all inductive arguments of a constructor have height below n then the instance of + * this constructor has height below n + 1. + * + * ` xi, ..., xj ∈ height(n) |- c(x1, ..., xn) ∈ height(n + 1)` + */ + private val heightConstructor = constructors + .map(c => + c -> Lemma((hIsTheHeightFunction, in(n, N), constructorVarsInDomain(c, app(h, n))) |- in(c.term, app(h, successor(n)))) { + + // Caching + val constructorInIntroFunHeight = isInIntroductionFunctionImage(app(h, n))(c.term) + + // Chaining the lemma on the elements of height n + 1 and the one on constructors being in the image of the introduction function + have((hIsTheHeightFunction, in(n, N), constructorInIntroFunHeight) |- in(c.term, app(h, successor(n)))) by Cut( + heightSuccessorWeak of (x := c.term), + ADTThm.equivalenceRevApply of (p1 := constructorInIntroFunHeight, p2 := in(c.term, app(h, successor(n)))) + ) + have((hIsTheHeightFunction, in(n, N), constructorVarsInDomain(c, app(h, n))) |- in(c.term, app(h, successor(n)))) by Cut(constructorIsInIntroductionFunction(c) of (s := app(h, n)), lastStep) + } + ) + .toMap + + /** + * Lemma --- If all inductive arguments of a constructor are in this ADT, and the non inductive ones in their respective domain, + * then the instance of this constructor is in this ADT as well. Also known as introduction rules. + * + * ` xi, ..., xj ∈ ADT |- c(x1, ..., xn) ∈ ADT` + */ + val intro = constructors + .map(c => { + c -> + Lemma(simplify(constructorVarsInDomain(c, term)) |- simplify(in(c.term, term))) { + // STEP 0: Instantiate the forward direction of termsHaveHeight. + val termsHaveHeightForward = have((hIsTheHeightFunction, constructorVarsInDomain(c, term)) |- ∃(n, in(n, N) /\ constructorVarsInDomain(c, app(h, n)))) by Cut( + termsHaveHeight(c), + ADTThm.equivalenceApply of (p1 := constructorVarsInDomain(c, term), p2 := exists(n, in(n, N) /\ constructorVarsInDomain(c, app(h, n)))) + ) + + // STEP 1: Prove that if an instance of a constructor has height n + 1 then it is in this ADT. + val left = have(in(n, N) |- in(successor(n), N)) by Cut(ADTThm.successorIsNat, ADTThm.equivalenceApply of (p1 := in(n, N), p2 := in(successor(n), N))) + val right = have(in(c.term, app(h, successor(n))) |- in(c.term, app(h, successor(n)))) by Hypothesis + have((in(n, N), in(c.term, app(h, successor(n)))) |- in(successor(n), N) /\ in(c.term, app(h, successor(n)))) by RightAnd(left, right) + thenHave((in(n, N), in(c.term, app(h, successor(n)))) |- exists(m, in(m, N) /\ in(c.term, app(h, m)))) by RightExists + have((hIsTheHeightFunction, in(n, N), in(c.term, app(h, successor(n)))) |- in(c.term, term)) by Apply(ADTThm.equivalenceRevApply).on(lastStep, termHasHeight.asInstanceOf) + + // STEP 2: Prove that if the inductive arguments of the constructor have height then the instance of the constructor is in the ADT. + have((hIsTheHeightFunction, in(n, N), constructorVarsInDomain(c, app(h, n))) |- in(c.term, term)) by Cut(heightConstructor(c), lastStep) + + // STEP 3: Prove that if the inductive arguments of the constructor are in the ADT then they have a height and therefore + // the instance of the constructor is in the ADT. + thenHave((hIsTheHeightFunction, in(n, N) /\ constructorVarsInDomain(c, app(h, n))) |- in(c.term, term)) by LeftAnd + thenHave((hIsTheHeightFunction, exists(n, in(n, N) /\ constructorVarsInDomain(c, app(h, n)))) |- in(c.term, term)) by LeftExists + have((hIsTheHeightFunction, constructorVarsInDomain(c, term)) |- in(c.term, term)) by Cut(termsHaveHeightForward, lastStep) + + // STEP 4: Remove lingering assumptions + thenHave((exists(h, hIsTheHeightFunction), constructorVarsInDomain(c, term)) |- in(c.term, term)) by LeftExists + have(constructorVarsInDomain(c, term) |- in(c.term, term)) by Cut(heightFunctionExistence, lastStep) + } + }) + .toMap + + // ************************ + // * STRUCTURAL INDUCTION * + // ************************ + + /** + * Lemma --- An element has height n + 1 if and only if it is the instance of some constructor with inductive arguments of height n. + * + * ` x ∈ height(n + 1) <=> x = c(x1, ..., xn) for some c and xi, ..., xj ∈ height(n)` + */ + private lazy val heightSuccessorStrong = Lemma((hIsTheHeightFunction, in(n, N)) |- in(x, app(h, successor(n))) <=> isConstructor(x, app(h, n))) { + val forward = have((hIsTheHeightFunction, in(n, N)) |- isInIntroductionFunctionImage(app(h, n))(x) ==> isConstructor(x, app(h, n))) subproof { + + def inductionFormula(n: Term): Formula = isInIntroductionFunctionImage(app(h, n))(x) ==> isConstructor(x, app(h, n)) + val inductionFormulaN: Formula = inductionFormula(n) + val inductionFormulaSuccN: Formula = inductionFormula(successor(n)) + + // STEP 1.1 : Base case + val isContructorXHEmptySet = isConstructor(x, app(h, emptySet)) + val baseCaseLeft = have(isContructorXHEmptySet |- isContructorXHEmptySet) by Hypothesis + val baseCaseRight = have((hIsTheHeightFunction, in(x, app(h, emptySet))) |- ()) by Restate.from(heightZero) + have((hIsTheHeightFunction, isInIntroductionFunctionImage(app(h, emptySet))(x)) |- isContructorXHEmptySet) by LeftOr(baseCaseLeft, baseCaseRight) + thenHave(hIsTheHeightFunction |- isInIntroductionFunctionImage(app(h, emptySet))(x) ==> isContructorXHEmptySet) by RightImplies + val inductiveCaseRemaining = have((hIsTheHeightFunction, forall(n, in(n, N) ==> (inductionFormulaN ==> inductionFormulaSuccN))) |- forall(n, in(n, N) ==> inductionFormulaN)) by Cut( + lastStep, + ADTThm.natInduction of (P := lambda(n, inductionFormulaN)) + ) + + // STEP 1.2: Unfolding the definition of subset + have(subset(app(h, n), app(h, successor(n))) |- forall(z, in(z, app(h, n)) ==> in(z, app(h, successor(n))))) by Cut( + subsetAxiom of (x := app(h, n), y := app(h, successor(n))), + ADTThm.equivalenceApply of (p1 := subset(app(h, n), app(h, successor(n))), p2 := forall(z, in(z, app(h, n)) ==> in(z, app(h, successor(n))))) + ) + val subsetElimination = thenHave(subset(app(h, n), app(h, successor(n))) |- in(y, app(h, n)) ==> in(y, app(h, successor(n)))) by InstantiateForall(y) + + // STEP 1.3 : Use monotonicity to prove that y ∈ height(n) => y ∈ height(n + 1) + have(in(n, N) |- in(successor(n), N)) by Cut(ADTThm.successorIsNat, ADTThm.equivalenceApply of (p1 := in(n, N), p2 := in(successor(n), N))) + have((hIsTheHeightFunction, in(n, N), subset(n, successor(n))) |- subset(app(h, n), app(h, successor(n)))) by Cut(lastStep, heightMonotonic of (n := successor(n), m := n)) + have((hIsTheHeightFunction, in(n, N)) |- subset(app(h, n), app(h, successor(n)))) by Cut(ADTThm.subsetSuccessor, lastStep) + val liftHeight = have((hIsTheHeightFunction, in(n, N)) |- in(y, app(h, n)) ==> in(y, app(h, successor(n)))) by Cut(lastStep, subsetElimination) + + // STEP 1.4 : Generalize the above result to show that if for some c, x = c(x1, ..., xn) with xi, ..., xj ∈ height(n) + // then for some c', x = c'(x1, ..., xn) with xi, ..., xj ∈ height(n + 1). + + // Caching + val isConstructorXHN = isConstructor(x, app(h, n)) + val isConstructorXHSuccN = isConstructor(x, app(h, successor(n))) + val liftConstructorHeight = + if constructors.size == 0 then have((hIsTheHeightFunction, in(n, N), isConstructorXHN) |- isConstructorXHSuccN) by Restate + else + val liftConstructorHeightOrSequence = + for c <- constructors yield + + // Caching + val isConstructorCXHN = isConstructor(c, x, app(h, n)) + val isConstructorCXHSuccN = isConstructor(c, x, app(h, successor(n))) + val constructorVarsInHN = constructorVarsInDomain(c, app(h, n)) + val constructorVarsInHSuccN = constructorVarsInDomain(c, app(h, successor(n))) + + if c.arity == 0 then have((hIsTheHeightFunction, in(n, N), isConstructorCXHN) |- isConstructorCXHSuccN) by Restate + else + val liftHeightAndSequence = + for (v, ty) <- c.signature + yield have((hIsTheHeightFunction, in(n, N), constructorVarsInHN) |- in(v, ty.getOrElse(app(h, successor(n))))) by Weakening(liftHeight of (y := v)) + + val left = have((hIsTheHeightFunction, in(n, N), constructorVarsInHN) |- constructorVarsInHSuccN) by RightAnd(liftHeightAndSequence: _*) + val right = have(x === c.term |- x === c.term) by Hypothesis + + have((hIsTheHeightFunction, in(n, N), constructorVarsInHN, (x === c.term)) |- constructorVarsInHSuccN /\ (x === c.term )) by RightAnd( + left, + right + ) + thenHave((hIsTheHeightFunction, in(n, N), constructorVarsInHN /\ (x === c.term)) |- constructorVarsInHSuccN /\ (x === c.term)) by LeftAnd + thenHave((hIsTheHeightFunction, in(n, N), constructorVarsInHN /\ (x === c.term)) |- isConstructorCXHSuccN) by QuantifiersIntro(c.variables) + thenHave((hIsTheHeightFunction, in(n, N), isConstructorCXHN) |- isConstructorCXHSuccN) by QuantifiersIntro(c.variables) + + thenHave((hIsTheHeightFunction, in(n, N), isConstructorCXHN) |- isConstructorXHSuccN) by Weakening + + have((hIsTheHeightFunction, in(n, N), isConstructorXHN) |- isConstructorXHSuccN) by LeftOr(liftConstructorHeightOrSequence: _*) + + // STEP 1.5: Show that x ∈ introductionFunction(height(n + 1)) => for some c, x = c(x1, ..., xn) + // with xi, ..., xj ∈ height(n + 1). + val heightSuccessorWeakForward = have((hIsTheHeightFunction, in(n, N), in(x, app(h, successor(n)))) |- isInIntroductionFunctionImage(app(h, n))(x)) by Cut( + heightSuccessorWeak, + ADTThm.equivalenceApply of (p1 := in(x, app(h, successor(n))), p2 := isInIntroductionFunctionImage(app(h, n))(x)) + ) + have((inductionFormulaN, isInIntroductionFunctionImage(app(h, n))(x)) |- isConstructorXHN) by Restate + have((hIsTheHeightFunction, in(n, N), in(x, app(h, successor(n))), inductionFormulaN) |- isConstructorXHN) by Cut(heightSuccessorWeakForward, lastStep) + val right = have((hIsTheHeightFunction, in(n, N), in(x, app(h, successor(n))), inductionFormulaN) |- isConstructorXHSuccN) by Cut(lastStep, liftConstructorHeight) + val left = have(isConstructorXHSuccN |- isConstructorXHSuccN) by Hypothesis + have((hIsTheHeightFunction, in(n, N), inductionFormulaN, isInIntroductionFunctionImage(app(h, successor(n)))(x)) |- isConstructorXHSuccN) by LeftOr(left, right) + + // STEP 1.6: Conclude + thenHave((hIsTheHeightFunction, in(n, N), inductionFormulaN) |- inductionFormulaSuccN) by RightImplies + thenHave((hIsTheHeightFunction, in(n, N)) |- inductionFormulaN ==> inductionFormulaSuccN) by RightImplies + thenHave(hIsTheHeightFunction |- in(n, N) ==> (inductionFormulaN ==> inductionFormulaSuccN)) by RightImplies + thenHave(hIsTheHeightFunction |- forall(n, in(n, N) ==> (inductionFormulaN ==> inductionFormulaSuccN))) by RightForall + have(hIsTheHeightFunction |- forall(n, in(n, N) ==> inductionFormulaN)) by Cut(lastStep, inductiveCaseRemaining) + thenHave(hIsTheHeightFunction |- in(n, N) ==> inductionFormulaN) by InstantiateForall(n) + } + + // STEP 2: Prove the backward implication + val backward = have((hIsTheHeightFunction, in(n, N)) |- isConstructor(x, app(h, n)) ==> isInIntroductionFunctionImage(app(h, n))(x)) by Restate + + // STEP 3: Conclude + have((hIsTheHeightFunction, in(n, N)) |- isInIntroductionFunctionImage(app(h, n))(x) <=> isConstructor(x, app(h, n))) by RightIff(forward, backward) + have(thesis) by Apply(ADTThm.equivalenceRewriting).on(lastStep, heightSuccessorWeak.asInstanceOf) + } + + /** + * Generates the structural inductive case for a given constructor. + * + * @param c the constructor + */ + lazy val inductiveCase: Map[SyntacticConstructor, Formula] = constructors + .map(c => + c -> c.signature.foldRight[Formula](P(c.term))((el, fc) => + val (v, ty) = el + ty match + case Self => forall(v, in(v, term) ==> (P(v) ==> fc)) + case GroundType(t) => forall(v, in(v, t) ==> fc) + ) + ) + .toMap + + /** + * Lemma --- Structural induction principle for this ADT. + * + * `base cases => inductive cases => ∀x ∈ ADT. P(x)` + */ + lazy val induction = Lemma(constructors.foldRight[Formula](forall(x, in(x, term) ==> P(x)))((c, f) => inductiveCase(c) ==> f)) { + + // List of cases to prove for structural induction to hold + val structuralInductionPreconditions: Formula = /\(constructors.map(inductiveCase)) + + // We want to prove the claim by induction on the height of n, i.e. prove that for any + // n in N, P holds. + def inductionFormula(n: Term): Formula = forall(x, in(x, app(h, n)) ==> P(x)) + val inductionFormulaN: Formula = inductionFormula(n) + + // STEP 1: Prove the base case + have(hIsTheHeightFunction |- in(x, app(h, emptySet)) ==> P(x)) by Weakening(heightZero) + val zeroCase = thenHave(hIsTheHeightFunction |- inductionFormula(emptySet)) by RightForall + + val inductiveCaseRemaining = have((hIsTheHeightFunction, forall(n, in(n, N) ==> (inductionFormulaN ==> inductionFormula(successor(n))))) |- forall(n, in(n, N) ==> inductionFormulaN)) by Cut( + zeroCase, + ADTThm.natInduction of (P := lambda(n, inductionFormulaN)) + ) + + // STEP 2: Prove the inductive case + val succCase = have((hIsTheHeightFunction, structuralInductionPreconditions) |- forall(n, in(n, N) ==> (inductionFormulaN ==> inductionFormula(successor(n))))) subproof { + + // STEP 2.1 : Prove that if the x = c(x1, ..., xn) for some c and xi, ..., xj ∈ height(n) then P(x) holds. + val isConstructorImpliesP = have((hIsTheHeightFunction, structuralInductionPreconditions, in(n, N), inductionFormulaN, isConstructor(x, app(h, n))) |- P(x)) subproof { + + if constructors.isEmpty then have(thesis) by Restate + else + val orSeq = + (for c <- constructors yield + + // Caching + val constructorPrecondition = inductiveCase(c) + val constructorVarsInHN = constructorVarsInDomain(c, app(h, n)) + val constructorVarsInHNEx = ∃(n, in(n, N) /\ constructorVarsInDomain(c, app(h, n))) + val constructorVarsInTerm = constructorVarsInDomain(c, term) + + // STEP 2.1.1: Prove that if xi, ..., xj ∈ height(n) then xi, ..., xj ∈ ADT. + val constructorQuantVarsInHNToTerm = have((hIsTheHeightFunction, in(n, N), constructorVarsInHN) |- constructorVarsInTerm) subproof { + have((hIsTheHeightFunction, in(n, N), constructorVarsInHN) |- in(n, N) /\ constructorVarsInHN) by Restate + val consVarL = thenHave((hIsTheHeightFunction, in(n, N), constructorVarsInHN) |- constructorVarsInHNEx) by RightExists + have((constructorVarsInTerm <=> constructorVarsInHNEx, constructorVarsInHNEx) |- constructorVarsInTerm) by Restate.from( + ADTThm.equivalenceRevApply of (p1 := constructorVarsInTerm, p2 := constructorVarsInHNEx) + ) + have((hIsTheHeightFunction, constructorVarsInHNEx) |- constructorVarsInTerm) by Cut( + termsHaveHeight(c), + lastStep + ) + have(thesis) by Cut(consVarL, lastStep) + } + + + // STEP 2.1.2: Prove that if xi, ..., xj ∈ height(n) then P(c(x1, ..., xn)). + have((hIsTheHeightFunction, constructorPrecondition, in(n, N), inductionFormulaN, constructorVarsInHN) |- constructorPrecondition) by Restate + + c.signature + .foldLeft(lastStep)((fact, el) => + val (v, ty) = el + + fact.statement.right.head match + case Forall(_, factCclWithoutForall) => + thenHave((hIsTheHeightFunction, constructorPrecondition, in(n, N), inductionFormulaN, constructorVarsInHN) |- factCclWithoutForall) by InstantiateForall(v) + + factCclWithoutForall match + case Implies(membership, subformula) => + ty match + case Self => + subformula match + case Implies(hypothesis, subSubFormula) => + val proofSubSubFormula = thenHave( + (hIsTheHeightFunction, constructorPrecondition, in(n, N), inductionFormulaN, constructorVarsInTerm, constructorVarsInHN, P(v)) |- subSubFormula + ) by Weakening + + have(inductionFormulaN |- inductionFormulaN) by Hypothesis + thenHave(inductionFormulaN |- in(v, app(h, n)) ==> P(v)) by InstantiateForall(v) + thenHave((inductionFormulaN, constructorVarsInHN) |- P(v)) by Weakening + + have((hIsTheHeightFunction, constructorPrecondition, in(n, N), inductionFormulaN, constructorVarsInTerm, constructorVarsInHN) |- subSubFormula) by Cut( + lastStep, + proofSubSubFormula + ) + have((hIsTheHeightFunction, constructorPrecondition, in(n, N), inductionFormulaN, constructorVarsInHN) |- subSubFormula) by Cut( + constructorQuantVarsInHNToTerm, + lastStep + ) + + case _ => throw UnreachableException + + case GroundType(t) => + thenHave((hIsTheHeightFunction, constructorPrecondition, in(n, N), inductionFormulaN, constructorVarsInHN) |- subformula) by Restate + case _ => throw UnreachableException + case _ => throw UnreachableException + ) + + thenHave((hIsTheHeightFunction, constructorPrecondition, in(n, N), inductionFormulaN, constructorVarsInHN) |- P(c.term)) by Restate + + // STEP 2.1.3: Prove that if xi, ..., xj ∈ height(n) then P(x). + thenHave((hIsTheHeightFunction, constructorPrecondition, in(n, N), inductionFormulaN, constructorVarsInHN, x === c.term) |- P(x)) by RightSubstEq + .withParametersSimple(List((x, c.term)), lambda(x, P(x))) + + thenHave((hIsTheHeightFunction, constructorPrecondition, in(n, N), inductionFormulaN, constructorVarsInHN /\ (x === c.term)) |- P(x)) by LeftAnd + + thenHave((hIsTheHeightFunction, constructorPrecondition, in(n, N), inductionFormulaN, isConstructor(c, x, app(h, n))) |- P(x)) by QuantifiersIntro(c.variables) + thenHave((hIsTheHeightFunction, structuralInductionPreconditions, in(n, N), inductionFormulaN, isConstructor(c, x, app(h, n))) |- P(x)) by Weakening + ).toSeq + + + have((hIsTheHeightFunction, structuralInductionPreconditions, in(n, N), inductionFormulaN, isConstructor(x, app(h, n))) |- P(x)) by LeftOr(orSeq: _*) + } + + // STEP 2.2: Prove that if x ∈ height(n + 1) then P(x) holds. + have((hIsTheHeightFunction, in(n, N), in(x, app(h, successor(n)))) |- isConstructor(x, app(h, n))) by Cut( + heightSuccessorStrong, + ADTThm.equivalenceApply of (p1 := in(x, app(h, successor(n))), p2 := isConstructor(x, app(h, n))) + ) + have((hIsTheHeightFunction, structuralInductionPreconditions, in(n, N), inductionFormulaN, in(x, app(h, successor(n)))) |- P(x)) by Cut(lastStep, isConstructorImpliesP) + + // STEP 2.3: Conclude + thenHave((hIsTheHeightFunction, structuralInductionPreconditions, in(n, N), inductionFormulaN) |- in(x, app(h, successor(n))) ==> P(x)) by RightImplies + + thenHave((hIsTheHeightFunction, structuralInductionPreconditions, in(n, N), inductionFormulaN) |- inductionFormula(successor(n))) by RightForall + thenHave((hIsTheHeightFunction, structuralInductionPreconditions, in(n, N)) |- inductionFormulaN ==> inductionFormula(successor(n))) by RightImplies + thenHave((hIsTheHeightFunction, structuralInductionPreconditions) |- in(n, N) ==> (inductionFormulaN ==> inductionFormula(successor(n)))) by RightImplies + thenHave(thesis) by RightForall + } + + // STEP 3: Conclude + + have((hIsTheHeightFunction, structuralInductionPreconditions) |- forall(n, in(n, N) ==> inductionFormulaN)) by Cut(lastStep, inductiveCaseRemaining) + thenHave((hIsTheHeightFunction, structuralInductionPreconditions) |- in(n, N) ==> inductionFormulaN) by InstantiateForall(n) + thenHave((hIsTheHeightFunction, structuralInductionPreconditions, in(n, N)) |- inductionFormulaN) by Restate + thenHave((hIsTheHeightFunction, structuralInductionPreconditions, in(n, N)) |- in(x, app(h, n)) ==> P(x)) by InstantiateForall(x) + thenHave((hIsTheHeightFunction, structuralInductionPreconditions, in(n, N) /\ in(x, app(h, n))) |- P(x)) by Restate + val exImpliesP = thenHave((hIsTheHeightFunction, structuralInductionPreconditions, exists(n, in(n, N) /\ in(x, app(h, n)))) |- P(x)) by LeftExists + have((hIsTheHeightFunction, in(x, term)) |- exists(n, in(n, N) /\ in(x, app(h, n)))) by Cut(termHasHeight, ADTThm.equivalenceApply of (p1 := in(x, term), p2 := exists(n, in(n, N) /\ in(x, app(h, n))))) + + have((hIsTheHeightFunction, structuralInductionPreconditions, in(x, term)) |- P(x)) by Cut(lastStep, exImpliesP) + thenHave((exists(h, hIsTheHeightFunction), structuralInductionPreconditions, in(x, term)) |- P(x)) by LeftExists + have((structuralInductionPreconditions, in(x, term)) |- P(x)) by Cut(heightFunctionExistence, lastStep) + thenHave(structuralInductionPreconditions |- in(x, term) ==> P(x)) by RightImplies + thenHave(structuralInductionPreconditions |- forall(x, in(x, term) ==> P(x))) by RightForall + } + +} + +/** + * Semantic set theoretical interpretation of a constructor for an algebraic data type. + * That is a function from the arguments' domains to the set of instances of the algebraic data type. + * + * `c : T1 -> ... -> Tn -> ADT` + * + * Since polymorphism is supported, this function is parametrized by the type variables appearing inside + * the specification of the ADT. In this sense, a constructor is a class function whose parameters are + * type variables and whose body is the set theoretic function detailed above. With polymorphism, the signature + * thus becomes: + * + * `c(X1, ..., Xn) : T1(X1, ..., Xn) -> ... -> Tn(X1, ..., Xn) -> ADT(X1, ..., Xn)` + * + * Injectivity and introduction rule are proven within this class. + * + * @constructor generates a class function for this constructor + * @param line the line at which this constructor is defined. Usually fetched automatically by the compiler. + * Used for error reporting + * @param file the file in which this constructor is defined. Usually fetched automatically by the compiler. + * Used for error reporting + * @param name the name of this constructor + * @param underlying the syntactic constructor + * @param adt the algebraic data type to which this constructor belongs + */ +private class SemanticConstructor[N <: Arity](using line: sourcecode.Line, file: sourcecode.File)( + val name: String, + val underlying: SyntacticConstructor, + val adt: SyntacticADT[N], +) { + /** + * Full name of this constructor, i.e. concatenation of the ADT name and this constructor name. + */ + val fullName: String = s"${adt.name}/${name}" + + /** + * Type variables that may appear in the signature of this constructor. + */ + val typeVariables: Variable ** N = adt.typeVariables + + /** + * Sequence of type variables that may appear in the signature of this constructor. + */ + val typeVariablesSeq: Seq[Variable] = adt.typeVariablesSeq + + /** + * Number of type variables in the signature of this constructor. + */ + val typeArity: N = adt.typeArity + + /** + * Variables used for constructor arguments. + */ + val variables: Seq[Variable] = underlying.variables + + /** + * Variables used for constructor arguments. + */ + val variables1: Seq[Variable] = underlying.variables1 + + /** + * Alternative set of variables used for constructor arguments. + */ + val variables2: Seq[Variable] = underlying.variables2 + + /** + * Set of variables for this constructor with their respective domain or a + * special symbol in case the domain is the ADT. + * + * @param vars variables + */ + def syntacticSignature(vars: Seq[Variable]): Seq[(Variable, ConstructorArgument)] = + vars.zip(underlying.specification) + + /** + * Variables of this constructor with their respective domain or a special symbol in case the domain is the ADT. + */ + val syntacticSignature: Seq[(Variable, ConstructorArgument)] = underlying.signature + + /** + * Constructor arguments with their respective domains. + * + * @param vars this constructor arguments + */ + def semanticSignature(vars: Seq[Variable]): Seq[(Variable, Term)] = vars.zip(underlying.specification.map(_.getOrElse(adt.term))) + + /** + * Variables of this constructor with their respective domains. + */ + val semanticSignature: Seq[(Variable, Term)] = semanticSignature(variables) + + /** + * Variables of this constructor with their respective domains. + */ + val semanticSignature1: Seq[(Variable, Term)] = semanticSignature + + /** + * Alternative set of variables of this constructor with their respective domain. + */ + val semanticSignature2: Seq[(Variable, Term)] = semanticSignature(variables2) + + /** + * Type of this constructor. + */ + val typ: Term = semanticSignature.unzip._2.foldRight[Term](adt.term)((a, b) => a |=> b) + + /** + * Arity of this constructor. + */ + val arity: Int = variables.size + + /** + * Internal representation of this constructor (i.e. as a tuple). + */ + val structuralTerm: Term = underlying.term + /** + * Internal representation of this constructor (i.e. as a tuple). + */ + val structuralTerm1: Term = underlying.term1 + /** + * Internal representation of this constructor (i.e. as a tuple) with an alternative set of variables. + */ + val structuralTerm2: Term = underlying.term2 + + /** + * Definition of this constructor. + * + * Formally it is the only function whose codomain is the ADT such that for all variables x1 :: S1, ...,xn :: Sn + * c * x1 * ... * xn = (tagc, (x1, (..., (xn, ∅)...)) + */ + private val untypedDefinition = (c :: typ) /\ forallSeq(variables, wellTypedFormula(semanticSignature) ==> (appSeq(c)(variables) === structuralTerm)) + + /** + * Lemma --- Uniqueness of this constructor. + * + * ` ∃!c. c ∈ T1 -> ... -> Tn -> ADT /\ ∀x1, ..., xn. c * x1 * ...* xn = (tagc, (x1, (..., (xn, ∅)...))` + */ + private val uniqueness = Axiom(existsOne(c, untypedDefinition)) + + /** + * Class function representing this constructor + */ + private val classFunction = FunctionDefinition[N](fullName, line.value, file.value)(typeVariablesSeq, c, untypedDefinition, uniqueness).label + + /** + * Identifier of this constructor. + */ + val id: Identifier = classFunction.id + + /** + * This constructor in which type variables are instantiated. + * + * @param args the instances of this constructor's type variables + */ + def term(args: Seq[Term]): Term = classFunction.applySeq(args) + + /** + * Constructor where type variables are instantiated with schematic variables. + */ + private val term: Term = term(typeVariablesSeq) + + /** + * Constructor where type variables are instantiated with schematic variables and arguments instantiated. + * + * @param args the instances of this constructor arguments + */ + def appliedTerm(args: Seq[Term]): Term = appSeq(term)(args) + + /** + * Constructor where type variables and arguments are instantiated with schematic variables. + */ + val appliedTerm: Term = appliedTerm(variables) + + /** + * Constructor where type variables and arguments are instantiated with schematic variables. + */ + val appliedTerm1: Term = appliedTerm + + /** + * Constructor where type variables and arguments are instantiated with schematic variables. + * Arguments variables are however drawn from an alternative set of variables. + */ + val appliedTerm2: Term = appliedTerm(variables2) + + /** + * Lemma --- This constructor is equal to its internal representation. + * + * `∀x1, ..., xn. c * x1 * ... * xn = (tagc, (x1, (..., (xn, ∅)...))` + */ + val shortDefinition = Lemma(forallSeq(variables, wellTypedFormula(semanticSignature) ==> (appliedTerm === structuralTerm))) { + have(forall(c, (term === c) <=> untypedDefinition)) by Exact(classFunction.definition) + thenHave((term === term) <=> ((term :: typ) /\ forallSeq(variables, wellTypedFormula(semanticSignature) ==> (appliedTerm === structuralTerm)))) by InstantiateForall(term) + thenHave(thesis) by Weakening + } + + /** + * Lemma --- Introduction rule for this constructor. + * + * `∀A1, ..., Am. c(X1, ..., Xm) ∈ T1(X1, ..., Xm) -> ... -> Tn(X1, ..., Xm) -> ADT(X1, ..., Xm)` + * + * where Ai are the type variables of the ADT and Ti are domains of this constructor arguments. + * + * e.g. `∀T. nil(T) ∈ list(T)` and `∀T. cons(T) ∈ T -> list(T) -> list(T)` + */ + val intro = Lemma(forallSeq(typeVariablesSeq, term :: typ)) { + have(forall(c, (term === c) <=> untypedDefinition)) by Exact(classFunction.definition) + thenHave((term === term) <=> ((term :: typ) /\ forallSeq(variables, wellTypedFormula(semanticSignature) ==> (appliedTerm === structuralTerm)))) by InstantiateForall(term) + thenHave(term :: typ) by Weakening + thenHave(thesis) by QuantifiersIntro(typeVariablesSeq) + } + + /** + * Theorem --- Injectivity of constructors. + * + * Two instances of this constructor are equal if and only if all of their arguments are pairwise equal + * + * e.g. Cons(head1, tail1) === Cons(head2, tail2) <=> head1 === head2 /\ tail1 === tail2 + */ + lazy val injectivity = + val vars1WellTyped: Set[Formula] = wellTypedSet(semanticSignature1) + val vars2WellTyped: Set[Formula] = wellTypedSet(semanticSignature2) + + if arity == 0 then + Lemma(appliedTerm1 === appliedTerm2) { + have(thesis) by RightRefl + } + else + Lemma(vars1WellTyped ++ vars2WellTyped |- simplify((appliedTerm1 === appliedTerm2) <=> (variables1 === variables2))) { + + have(forallSeq(variables1, wellTypedFormula(semanticSignature1) ==> (appliedTerm1 === structuralTerm1))) by Restate.from(shortDefinition) + + variables1.foldLeft(lastStep)((fact, v) => + fact.statement.right.head match + case Forall(_, phi) => thenHave(phi) by InstantiateForall(v) + case _ => throw UnreachableException + ) + val tappTerm1Def = thenHave(vars1WellTyped |- appliedTerm1 === structuralTerm1) by Restate + + // println(forallSeq(variables1, wellTypedFormula(semanticSignature1) ==> (appliedTerm1 === structuralTerm1))) + // println(forallSeq(variables2, wellTypedFormula(semanticSignature2) ==> (appliedTerm2 === structuralTerm))) + have(forallSeq(variables2, wellTypedFormula(semanticSignature2) ==> (appliedTerm2 === structuralTerm2))) by Restate.from(shortDefinition) + + variables2.foldLeft(lastStep)((fact, v) => + fact.statement.right.head match + case Forall(_, phi) => thenHave(phi) by InstantiateForall(v) + case _ => throw UnreachableException + ) + val tappTerm2Def = thenHave(vars2WellTyped |- appliedTerm2 === structuralTerm2) by Restate + + + val s0 = have(vars2WellTyped + (appliedTerm1 === appliedTerm2) |- appliedTerm1 === structuralTerm2) by Cut(tappTerm2Def, + ADTThm.altEqualityTransitivity of (x := appliedTerm1, y := appliedTerm2, z := structuralTerm2)) + have(vars1WellTyped + (appliedTerm1 === structuralTerm2) |- structuralTerm1 === structuralTerm2) by Cut(tappTerm1Def, + ADTThm.altEqualityTransitivity of (x := structuralTerm1, y := appliedTerm1, z := structuralTerm2)) + have((vars1WellTyped ++ vars2WellTyped) + (appliedTerm1 === appliedTerm2) |- structuralTerm1 === structuralTerm2) by Cut(s0, lastStep) + val forward = thenHave(vars1WellTyped ++ vars2WellTyped |- (appliedTerm1 === appliedTerm2) ==> (structuralTerm1 === structuralTerm2)) by RightImplies + + val s1 = have(vars1WellTyped + (structuralTerm1 === structuralTerm2) |- appliedTerm1 === structuralTerm2) by Cut(tappTerm1Def, + ADTThm.altEqualityTransitivity of (x := appliedTerm1, y := structuralTerm1, z := structuralTerm2)) + have(vars2WellTyped + (appliedTerm1 === structuralTerm2) |- appliedTerm1 === appliedTerm2) by Cut(tappTerm2Def, + ADTThm.altEqualityTransitivity of (x := appliedTerm1, y := structuralTerm2, z := appliedTerm2)) + have((vars1WellTyped ++ vars2WellTyped) + (structuralTerm1 === structuralTerm2) |- appliedTerm1 === appliedTerm2) by Cut(s1, lastStep) + val backward = thenHave(vars1WellTyped ++ vars2WellTyped |- (structuralTerm1 === structuralTerm2) ==> (appliedTerm1 === appliedTerm2)) by RightImplies + + val definitionUnfolding = have(vars1WellTyped ++ vars2WellTyped |- (appliedTerm1 === appliedTerm2) <=> (structuralTerm1 === structuralTerm2)) by RightIff(forward, backward) + have((appliedTerm1 === appliedTerm2) <=> (structuralTerm1 === structuralTerm2) |- (appliedTerm1 === appliedTerm2) <=> /\(variables1.zip(variables2).map(_ === _))) by Sorry + Cut( + underlying.injectivity, + ADTThm.equivalenceRewriting of (p1 := (appliedTerm1 === appliedTerm2), p2 := (structuralTerm1 === structuralTerm2), p3 := /\(variables1.zip(variables2).map(_ === _))) + ) + have(thesis) by Cut(definitionUnfolding, lastStep) + } + + + /** + * Case generated by this constructor when performing a proof by induction + */ + lazy val inductiveCase: Formula = + syntacticSignature.foldRight[Formula](P(appliedTerm1)) + ((el, fc) => + val (v, typ) = el + typ match + case Self => forall(v, v :: adt.term ==> (P(v) ==> fc)) + case GroundType(t) => forall(v, v :: t ==> fc) + ) +} + +/** + * Semantic set theoretical interpretation of an algebraic data type. That is the least set closed under [[SemanticConstructor]]. + * + * E.g. list is the smallest set containing nil and closed under the cons function. + * + * Injectivity between different constructors, structural induction and elimination rule are proved within this class. + * + * @constructor generates a semantic interpretation for this ADT out of a syntactic one + * @param underlying the syntactic representation of this ADT + * @param constructors constructors of this ADT + */ + private class SemanticADT[N <: Arity]( + val underlying: SyntacticADT[N], + val constructors: Seq[SemanticConstructor[N]] + ) { + + /** + * Name of this ADT. + */ + val name: String = underlying.name + + /** + * Identifier of this ADT. + */ + val id: Identifier = underlying.polymorphicTerm.id + + /** + * Type variables of this ADT. + */ + val typeVariables: Variable ** N = underlying.typeVariables + + /** + * Sequence of type variables of this ADT. + */ + val typeVariablesSeq: Seq[Variable] = underlying.typeVariablesSeq + + /** + * Number of type variables in this ADT. + */ + val typeArity: N = underlying.typeArity + + /** + * Term representing this ADT where type variables are instantiated with given arguments. + * + * @param args the instances of this ADT type variables + */ + def term(args: Seq[Term]) = underlying.polymorphicTerm.applySeq(args) + + /** + * Term representing this ADT where type variables are instantiated with schematic variables. + */ + val term: Term = underlying.term + + /** + * Theorem --- Injectivity of constructors. + * + * Two instances of different construcors are always different. + * + * e.g. Nil != Cons(head, tail) + */ + def injectivity(c1: SemanticConstructor[N], c2: SemanticConstructor[N]) = + + val vars1WellTyped: Set[Formula] = wellTypedSet(c1.semanticSignature1) + val vars2WellTyped: Set[Formula] = wellTypedSet(c2.semanticSignature2) + + Lemma(vars1WellTyped ++ vars2WellTyped |- !(c1.appliedTerm1 === c2.appliedTerm2)) { + + val defUnfolding = have((vars1WellTyped ++ vars2WellTyped) + (c1.appliedTerm1 === c2.appliedTerm2) |- c1.structuralTerm1 === c2.structuralTerm2) subproof { + have(forallSeq(c1.variables1, wellTypedFormula(c1.semanticSignature1) ==> (c1.appliedTerm1 === c1.structuralTerm1))) by Restate.from(c1.shortDefinition) + + c1.variables1.foldLeft(lastStep)((fact, v) => + fact.statement.right.head match + case Forall(_, phi) => thenHave(phi.substitute(v := x)) by InstantiateForall(x) + case _ => throw UnreachableException + ) + val tappTerm1Def = thenHave(vars1WellTyped |- c1.structuralTerm1 === c1.appliedTerm1) by Restate + + have(forallSeq(c2.variables2, wellTypedFormula(c2.semanticSignature2) ==> (c2.appliedTerm2 === c2.structuralTerm2))) by Restate.from(c2.shortDefinition) + + c2.variables2.foldLeft(lastStep)((fact, v) => + fact.statement.right.head match + case Forall(_, phi) => thenHave(phi) by InstantiateForall(v) + case _ => throw UnreachableException + ) + val tappTerm2Def = thenHave(vars2WellTyped |- c2.appliedTerm2 === c2.structuralTerm2) by Restate + + val s0 = have(vars2WellTyped + (c1.appliedTerm1 === c2.appliedTerm2) |- c1.appliedTerm1 === c2.structuralTerm2) by Cut( + tappTerm2Def, + ADTThm.altEqualityTransitivity of (x := c1.appliedTerm1, y := c2.appliedTerm2, z := c2.structuralTerm2) + ) + have(vars1WellTyped + (c1.appliedTerm1 === c2.structuralTerm2) |- c1.structuralTerm1 === c2.structuralTerm2) by Cut( + tappTerm1Def, + ADTThm.altEqualityTransitivity of (x := c1.structuralTerm1, y := c1.appliedTerm1, z := c2.structuralTerm2) + ) + have(thesis) by Cut(s0, lastStep) + } + + have(!(c1.structuralTerm1 === c2.structuralTerm2)) by Restate.from(underlying.injectivity(c1.underlying, c2.underlying)) + thenHave(c1.structuralTerm1 === c2.structuralTerm2 |- ()) by Restate + + have((vars1WellTyped ++ vars2WellTyped) + (c1.appliedTerm1 === c2.appliedTerm2) |- ()) by Cut(defUnfolding, lastStep) + } + + /** + * Theorem --- Structural induction principle for this ADT. + * + * `base cases => inductive cases => ∀x ∈ ADT. P(x)` + */ + lazy val induction = Lemma(constructors.foldRight[Formula](forall(x, x :: term ==> P(x)))((c, f) => c.inductiveCase ==> f)) { sp ?=> + constructors.foldRight[(Formula, Formula, sp.Fact)] { + val prop = forall(x, x :: term ==> P(x)) + (prop, prop, have(prop <=> prop) by Restate) + }((c, acc) => + val (oldBefore, oldAfter, fact) = acc + val newBefore = underlying.inductiveCase(c.underlying) ==> oldBefore + val newAfter = c.inductiveCase ==> oldAfter + + have(underlying.inductiveCase(c.underlying) <=> c.inductiveCase) subproof { + val wellTypedVars: Seq[Formula] = wellTyped(c.semanticSignature) + val wellTypedVarsSet = wellTypedVars.toSet + + + have(forallSeq(c.variables, wellTypedFormula(c.semanticSignature) ==> (c.appliedTerm === c.structuralTerm))) by Restate.from(c.shortDefinition) + if c.arity > 0 then + c.variables1.foldLeft(lastStep)((l, _) => + lastStep.statement.right.head match + case Forall(v, phi) => thenHave(phi) by InstantiateForall(v) + case _ => throw UnreachableException + ) + + val eq = thenHave(wellTypedVarsSet |- c.appliedTerm === c.structuralTerm) by Restate + have(P(c.appliedTerm) <=> P(c.appliedTerm)) by Restate + thenHave(c.structuralTerm === c.appliedTerm |- P(c.structuralTerm) <=> P(c.appliedTerm)) by RightSubstEq.withParametersSimple( + List((c.structuralTerm, c.appliedTerm)), + lambda(s, P(c.structuralTerm) <=> P(s)) + ) + have(wellTypedVarsSet |- P(c.structuralTerm) <=> P(c.appliedTerm)) by Cut(eq, lastStep) + + c.syntacticSignature + .foldRight[(Formula, Formula, Seq[Formula])]((P(c.structuralTerm), P(c.appliedTerm), wellTypedVars))((el, fc) => + val (v, ty) = el + val (fc1, fc2, wellTypedVars) = fc + ty match + case Self => + val wellTypedV: Formula = v :: term + have(wellTypedVars |- (P(v) ==> fc1) <=> (P(v) ==> fc2)) by Cut(lastStep, ADTThm.leftImpliesEquivalenceWeak of (p := P(v), p1 := fc1, p2 := fc2)) + thenHave(wellTypedVars.init |- wellTypedV ==> ((P(v) ==> fc1) <=> (P(v) ==> fc2))) by RightImplies + have(wellTypedVars.init |- (wellTypedV ==> (P(v) ==> fc1)) <=> (wellTypedV ==> (P(v) ==> fc2))) by Cut( + lastStep, + ADTThm.leftImpliesEquivalenceStrong of (p := wellTypedV, p1 := P(v) ==> fc1, p2 := P(v) ==> fc2) + ) + thenHave(wellTypedVars.init |- forall(v, (wellTypedV ==> (P(v) ==> fc1)) <=> (wellTypedV ==> (P(v) ==> fc2)))) by RightForall + have(wellTypedVars.init |- forall(v, (wellTypedV ==> (P(v) ==> fc1))) <=> forall(v, (wellTypedV ==> (P(v) ==> fc2)))) by Cut( + lastStep, + universalEquivalenceDistribution of (P := lambda(v, wellTypedV ==> (P(v) ==> fc1)), Q := lambda(v, wellTypedV ==> (P(v) ==> fc2))) + ) + (forall(v, wellTypedV ==> (P(v) ==> fc1)), forall(v, wellTypedV ==> (P(v) ==> fc2)), wellTypedVars.init) + case GroundType(t) => + thenHave(wellTypedVars.init |- v :: t ==> (fc1 <=> fc2)) by RightImplies + have(wellTypedVars.init |- (in(v, t) ==> fc1) <=> (v :: t ==> fc2)) by Cut(lastStep, ADTThm.leftImpliesEquivalenceStrong of (p := in(v, t), p1 := fc1, p2 := fc2)) + thenHave(wellTypedVars.init |- forall(v, (in(v, t) ==> fc1) <=> (v :: t ==> fc2))) by RightForall + have(wellTypedVars.init |- forall(v, (in(v, t) ==> fc1)) <=> forall(v, (v :: t ==> fc2))) by Cut( + lastStep, + universalEquivalenceDistribution of (P := lambda(v, in(v, t) ==> fc1), Q := lambda(v, v :: t ==> fc2)) + ) + (forall(v, (in(v, t) ==> fc1)), forall(v, (v :: t ==> fc2)), wellTypedVars.init) + ) + } + (newBefore, newAfter, have(newBefore <=> newAfter) by Apply(ADTThm.impliesEquivalence).on(lastStep, fact)) + ) + have(underlying.induction.statement.right.head |- thesis.right.head) by Cut( + lastStep, + ADTThm.equivalenceApply of ( + p1 := underlying.induction.statement.right.head, p2 := thesis.right.head + ) + ) + have(thesis) by Cut(underlying.induction, lastStep) + } + + /** + * Returns a map binding each constructor to formula describing whether x is an instance of it. + */ + private lazy val isConstructorMap: Map[SemanticConstructor[N], Formula] = + constructors.map(c => c -> existsSeq(c.variables, wellTypedFormula(c.semanticSignature) /\ (x === c.appliedTerm))).toMap + + /** + * Returns a formula describing whether x is an instance of one of this ADT's constructors. + */ + private lazy val isConstructor = + \/(constructors.map(c => isConstructorMap(c))) + + /** + * Theorem --- Pattern matching principle (also known as elimination rule) for this ADT. + * + * `x ∈ ADT |- x = c * x1 * ... * xn for some constructor c and xi, ..., xj ∈ ADT` + */ + lazy val elim = Lemma(x :: term |- simplify(isConstructor)) { + + // Induction preconditions with P(z) = z != x + val inductionPreconditionIneq = constructors.map(c => c -> c.inductiveCase.substitute((P -> lambda(z, !(x === z))))).toMap + val inductionPreconditionsIneq = /\(inductionPreconditionIneq.map(_._2)) + + // Weakening of the negation of the induction preconditions + val weakNegInductionPreconditionIneq: Map[SemanticConstructor[N], Formula] = constructors + .map(c => + c -> + c.semanticSignature + .foldRight[Formula](x === c.appliedTerm)((el, fc) => + val (v, t) = el + exists(v, (v :: t) /\ fc) + ) + ) + .toMap + + // STEP 1: Prove that if the induction preconditions with P(z) = z != x do not hold then x is the instance of some constructor + val strengtheningOfInductionPreconditions = have(!inductionPreconditionsIneq |- isConstructor) subproof { + if constructors.isEmpty then have(thesis) by Restate + else + + // STEP 1.1: Prove the claim for each constructor + val negInductionPreconditionsOrSequence = + for c <- constructors yield + + // STEP 1.1.1: Prove the strengthening of the negations of the induction preconditions + val conditionStrenghtening = have(!inductionPreconditionIneq(c) |- weakNegInductionPreconditionIneq(c)) subproof { + have(x === c.appliedTerm |- x === c.appliedTerm) by Hypothesis + + c.syntacticSignature + .foldRight(lastStep)((el, fact) => + val (v, ty) = el + val left = fact.statement.left.head + val right = fact.statement.right.head + + ty match + case Self => + thenHave(!(x === v) /\ left |- right) by Weakening + case _ => () + + val weakr = thenHave(in(v, ty.getOrElse(term)) /\ left |- right) by Weakening + val weakl = have(in(v, ty.getOrElse(term)) /\ left |- in(v, ty.getOrElse(term))) by Restate + + have((v :: ty.getOrElse(term)) /\ left |- (v :: ty.getOrElse(term)) /\ right) by RightAnd(weakl, weakr) + thenHave((v :: ty.getOrElse(term)) /\ left |- exists(v, (v :: ty.getOrElse(term)) /\ right)) by RightExists + thenHave(exists(v, (v :: ty.getOrElse(term)) /\ left) |- exists(v, (v :: ty.getOrElse(term)) /\ right)) by LeftExists + ) + + } + + // STEP 1.1.2: Conclude + // TODO: Change to a more efficient way of proving this + have(weakNegInductionPreconditionIneq(c) |- isConstructorMap(c)) by Tableau + have(!inductionPreconditionIneq(c) |- isConstructorMap(c)) by Cut(conditionStrenghtening, lastStep) + thenHave(!inductionPreconditionIneq(c) |- isConstructor) by Weakening + + have(thesis) by LeftOr(negInductionPreconditionsOrSequence: _*) + } + + // STEP 2: Conclude + have(inductionPreconditionsIneq |- forall(z, z :: term ==> !(x === z))) by Restate.from(induction of (P := lambda(z, !(x === z)))) + thenHave(inductionPreconditionsIneq |- x :: term ==> !(x === x)) by InstantiateForall(x) + val ind = thenHave(x :: term |- !inductionPreconditionsIneq) by Restate + have(x :: term |- isConstructor) by Cut(lastStep, strengtheningOfInductionPreconditions) + } + } + + + + + + diff --git a/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/package.scala b/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/package.scala new file mode 100644 index 000000000..7af2af24c --- /dev/null +++ b/lisa-sets/src/main/scala/lisa/maths/settheory/types/adt/package.scala @@ -0,0 +1,200 @@ +package lisa.maths.settheory.types + +/** + * Provides definitional mechanisms for Algebraic Data Types (ADTs) and tactics for reasoning about them. + * + * ===Usage=== + * + * In order to use ADTs, you need to import + * {{{ + * lisa.maths.settheory.types.adt.{*, given} + * }}} + * + * ====Defining an ADT==== + * + * ADTs can be defined using the following syntax: + * {{{ + * val define(adtName: ADT[N], constructors(c1, ..., cn)) = (X1, .., Xk) --> (T1, ..., Tn) | ... | (S1, ..., Sm) + * }}} + * + * where: + * - `adtName` is the identifier of the ADT + * - `N` is the number of poylmorphic variables + * - `c1 ... cn` are the identifiers of the different constructors of the ADT, + * - `X1, ..., Xk` are the polymorphic variables + * - `T1, ..., Tn, S1, ..., Sm` are the types defining the signature of each constructor. + * Note that `adtName` and `c1 ... cn` are scala identifiers, respectively referring to the ADT and the constructors. + * In addition, you cannot define two ADT with the same name, even in different scopes, as they introduce a new global definition. + * Type variables must be declarated as variables before being used. + * Here are some examples of ADT definitions: + * {{{ + * + * //variables declaration + * val A = variable + * + * // Definition of booleans with two constructors tru and fals. Each of them take no argument so their signature is () + * val define(bool: ADT, constructors(tru, fals)) = () | () + * + * // Definition of options with two constructors none and some. Options are polymorphic over a type variable A. + * // Their second constructor, some, has signature A has it takes only a value of type A. + * val define(option: ADT, constructors(none, some)) = A -> () | A + * + * // Recursive definition of lists with two constructors nil and cons. Lists are polymorphic over a type variable A. + * // The constructor cons takes two arguments of respectively type A and list(A) and append an element to + * // a sublist. + * val define(list: ADT, constructors(nil, cons)) = A -> () | (A, list) + * + * //Definition of natural numbers. + * val define(nat: ADT, constructors(zero, succ)) = () | nat + * }}} + * + * ====Using an ADT and its theorem==== + * + * Each constructor of an ADT comes with an introduction rule and an injectivity theorem. + * The introduction rule gives the type of the constructor and is of the form + * + * `∀ X1, ..., Xk. c(X1, ..., Xk) :: T1 -> ... Tn -> ADT(X1, ..., Xk)` + * + * The injection theorem stipulates that two instances of the same constructor are equal if and only if all their arguments are equal. + * + * For examples for lists we have + * + * nil introduction: `∀ A. nil(A) :: list(A)` + * + * cons introduction: `∀ A. cons(A) :: A -> list(A) -> list(A)` + * + * nil injectivity: `nil(A) = nil(A)` + * + * cons injectivity: `cons(A) * x0 * x1 = cons(A) * y0 * y1 <=> x0 = x1 /\ y0 = y1` + * + * Each ADT comes with an structural induction schema, an elimination rule (or pattern matching principle) and an injectivity theorem. + * + * Structural induction states that if a statement is true for each constructor assuming that the proposition is true for the constructor's + * arguments, then it is true for every element of the ADT. + * + * e.g. list induction: ` P(nil(A)) => (∀ x0 :: A. ∀ x1 :: list(A). P(x1) => P(cons * x0 * x1)) => ∀ x :: list(A). P(x)` + * + * Elimination rule is a direct consequence of induction and states that each instance of an ADT is an instance of one of its constructors + * + * e.g. list elimination: ` x :: list(A) => x = nil(A) \/ ∃ x0, x1. x = cons(A) * x0 * x1` + * + * Finally injectivity tells us that instances of different constructors are different + * + * e.g. nil/cons injectivity: `nil(A) != cons(A) * x0 * x1` + * + * ====Type Checking==== + * + * We provide a tactic to automatically type check instances of algebraic data types. + * It can be called using `TypeChecker.prove`. For examples instances of lists can be + * typechecked as follow. + * + * {{{ + * have(nil(A) :: list(A)) by TypeChecker.prove + * have((x :: A, l :: list(A)) |- cons * x * l :: list(A)) by TypeChecker.prove + * }}} + * + * ====Induction Tactic==== + * + * We provide a tactic for performing proofs by induction. + * The tactic can prove goals of the form + * + * ` ∀ x :: adt. P(x)` + * + * To work the user needs to provide a proof of P(c * x0 * ... * xn) for each constructor. + * The syntax of the tactic is of the following form: + * {{{ + * have(∀ x :: adt. P(x)) by Induction(adt) { + * Case(c1, v1, ..., vn) { + * // proof of (v1 :: T1, ..., vn :: Tn, P(vi), ..., P(vj)) |- P(c1 * v0 * ... * vn) + * } + * ... + * Case(ck, v1, ..., vm) { + * // proof of (v1 :: S1, ..., vm :: Sm, P(vi), ..., P(vj)) |- P(ck * v0 * ... * vn) + * } + * } + * }}} + * + * For lists it would look like: + * {{{ + * have(∀ x :: list(A). P(x)) by Induction(list) { + * Case(nil) { + * // ... + * have(P(nil)) by //Tactic to conclude the subcase + * } + * Case(cons, x, l) { + * // ... + * have((x :: A, l :: list(A), P(l)) |- P(cons * x * l)) by //Tactic to conclude the subcase + * } + * } + * }}} + * + * ====Defining functions==== + * + * Functions over ADT can also be defined via the following syntax: + * + * {{{ + * val myFunction = fun(adt, returnType) { + * Case(c1, v1, ..., vn) { + * body1 + * } + * ... + * Case(ck, v1, ..., vm) { + * bodyk + * } + * } + * }}} + * + * The body of each case is automatically typechecked at runtime. + * For example let's define the predecessor function over natural numbers + * + * {{{ + * val pred = fun(nat, nat) { + * Case(zero) { + * zero + * } + * Case(succ, n) { + * n + * } + * } + * }}} + * + * Recursive functions are not yet supported. + * + * ====Using functions==== + * + * Functions come with an introduction and elimination rules. + * Their introduction rule is of the form + * + * `∀ X1, ..., Xk. f(X1, ..., Xk) :: ADT(X1, ..., Xk) -> T` + * + * where `T` is the return type of the function + * + * On the other hand, we have an elimination rule for each constructor, giving the result of the function when applied to some + * constructor + * + * ` f * (ck * v1 * ... * vn) = body(ck) ` + * + * For example, for the `pred` function defined above the introduction rule would be + * + * `pred :: nat -> nat` + * + * and its elimination rules + * + * ` pred * zero = zero` + * + * ` pred * (succ * n) = n` + * + * Functions are also fully compatible with the typechecking tactic. We can for instance write: + * + * {{{ + * have(n :: nat |- pred * succ * n :: nat) + * }}} + * + * + */ +package object adt { + export ADTSyntax.{ |, define, constructors, adt_to_term, fun_to_term, constructor_to_term, Case, fun, -->} + export ADTSyntax.ADTBuilder.| + export lisa.maths.settheory.types.TypeSystem.* +} + diff --git a/lisa-utils/src/main/scala/lisa/fol/Common.scala b/lisa-utils/src/main/scala/lisa/fol/Common.scala index cb1ca1eeb..77977eb2a 100644 --- a/lisa-utils/src/main/scala/lisa/fol/Common.scala +++ b/lisa-utils/src/main/scala/lisa/fol/Common.scala @@ -135,6 +135,7 @@ trait Common { * Renames the symbol with an identifier that is fresh for the given list. */ def freshRename(taken: Iterable[Identifier]): Label[A] + } /** @@ -276,7 +277,7 @@ trait Common { sealed trait FunctionLabel[N <: Arity] extends TermLabel[(Term ** N) |-> Term] with ((Term ** N) |-> Term) { val underlyingLabel: K.TermLabel def substituteUnsafe(map: Map[SchematicLabel[_], LisaObject[_]]): (Term ** N) |-> Term - def applyUnsafe(args: (Term ** N)): Term = AppliedFunction(this, args.toSeq) + def applyUnsafe(args: (Term ** N)): Term = AppliedFunctional(this, args.toSeq) override def rename(newid: Identifier): FunctionLabel[N] def freshRename(taken: Iterable[Identifier]): FunctionLabel[N] } @@ -285,7 +286,7 @@ trait Common { * A Variable, corresponding to [[K.VariableLabel]], is a schematic symbol for terms. * It counts both as the label and as the term itself. */ - case class Variable(id: Identifier) extends SchematicTermLabel[Term] with Term with Absolute { + class Variable(val id: Identifier) extends SchematicTermLabel[Term] with Term with Absolute { val arity: 0 = 0 val label: Variable = this val args: Seq[Nothing] = Seq.empty @@ -308,13 +309,35 @@ trait Common { def freshRename(taken: Iterable[Identifier]): Variable = rename(K.freshId(taken, id)) override def toString(): String = id def mkString(args: Seq[Term]): String = if (args.size == 0) toString() else toString() + "(" + "illegal_arguments: " + args.mkString(", ") + ")" + + def canEqual(that: Any): Boolean = + that.isInstanceOf[Variable] + + // Intentionally avoiding the call to super.equals because no ancestor has overridden equals (see note 7 below) + override def equals(that: Any): Boolean = + that match { + case other: Variable => + ((this eq other) // optional, but highly recommended sans very specific knowledge about this exact class implementation + || (other.canEqual(this) // optional only if this class is marked final + && (hashCode == other.hashCode) // optional, exceptionally execution efficient if hashCode is cached, at an obvious space inefficiency tradeoff + && ((id == other.id)))) + case _ => + false + } + + // Intentionally avoiding the call to super.hashCode because no ancestor has overridden hashCode (see note 7 below) + override def hashCode(): Int = + id.## + } + object Variable { + def unapply(variable: Variable): Option[Identifier] = Some(variable.id) } /** * A Constant, corresponding to [[K.ConstantLabel]], is a label for terms. * It counts both as the label and as the term itself. */ - case class Constant(id: Identifier) extends Term with Absolute with ConstantTermLabel[Constant] with LisaObject[Constant] { + class Constant(val id: Identifier) extends Term with Absolute with ConstantTermLabel[Constant] with LisaObject[Constant] { val arity: 0 = 0 val label: Constant = this val args: Seq[Nothing] = Seq.empty @@ -328,17 +351,39 @@ trait Common { def freshRename(taken: Iterable[Identifier]): Constant = rename(K.freshId(taken, id)) override def toString(): String = id def mkString(args: Seq[Term]): String = if (args.size == 0) toString() else toString() + "(" + "illegal_arguments: " + args.mkString(", ") + ")" + + def canEqual(that: Any): Boolean = + that.isInstanceOf[Constant] + + // Intentionally avoiding the call to super.equals because no ancestor has overridden equals (see note 7 below) + override def equals(that: Any): Boolean = + that match { + case other: Constant => + ((this eq other) // optional, but highly recommended sans very specific knowledge about this exact class implementation + || (other.canEqual(this) // optional only if this class is marked final + && (hashCode == other.hashCode) // optional, exceptionally execution efficient if hashCode is cached, at an obvious space inefficiency tradeoff + && ((id == other.id)))) + case _ => + false + } + + // Intentionally avoiding the call to super.hashCode because no ancestor has overridden hashCode (see note 7 below) + override def hashCode(): Int = + id.## + } + object Constant { + def unapply(constant: Constant): Option[Identifier] = Some(constant.id) } /** * A schematic functional label (corresponding to [[K.SchematicFunctionLabel]]) is a functional label and also a schematic label. * It can be substituted by any expression of type (Term ** N) |-> Term */ - case class SchematicFunctionLabel[N <: Arity](val id: Identifier, val arity: N) extends SchematicTermLabel[(Term ** N) |-> Term] with FunctionLabel[N] { + class SchematicFunctionLabel[N <: Arity](val id: Identifier, val arity: N) extends SchematicTermLabel[(Term ** N) |-> Term] with FunctionLabel[N] { val underlyingLabel: K.SchematicTermLabel = K.SchematicFunctionLabel(id, arity) - def unapplySeq(t: AppliedFunction): Seq[Term] = t match { - case AppliedFunction(label, args) if (label == this) => args + def unapplySeq(t: AppliedFunctional): Seq[Term] = t match { + case AppliedFunctional(label, args) if (label == this) => args case _ => Seq.empty } @nowarn("msg=the type test for.*cannot be checked at runtime because its type arguments") @@ -359,16 +404,41 @@ trait Common { override def toString(): String = id def mkString(args: Seq[Term]): String = toString() + "(" + args.mkString(", ") + ")" override def mkStringSeparated(args: Seq[Term]): String = mkString(args) + + def canEqual(that: Any): Boolean = + that.isInstanceOf[SchematicFunctionLabel[?]] + + // Intentionally avoiding the call to super.equals because no ancestor has overridden equals (see note 7 below) + override def equals(that: Any): Boolean = + that match { + case other: SchematicFunctionLabel[N] => + ((this eq other) // optional, but highly recommended sans very specific knowledge about this exact class implementation + || (other.canEqual(this) // optional only if this class is marked final + && (hashCode == other.hashCode) // optional, exceptionally execution efficient if hashCode is cached, at an obvious space inefficiency tradeoff + && ((id == other.id) + && (arity == other.arity)))) + case _ => + false + } + + // Intentionally avoiding the call to super.hashCode because no ancestor has overridden hashCode (see note 7 below) + override def hashCode(): Int = + 31 * ( + id.## + ) + arity.## + } + object SchematicFunctionLabel { + def unapply[N <: Arity](sfl: SchematicFunctionLabel[N]): Option[(Identifier, N)] = Some((sfl.id, sfl.arity)) } /** * A constant functional label of arity N. */ - case class ConstantFunctionLabel[N <: Arity](id: Identifier, arity: N) extends ConstantTermLabel[((Term ** N) |-> Term)] with FunctionLabel[N] { + class ConstantFunctionLabel[N <: Arity](val id: Identifier, val arity: N) extends ConstantTermLabel[((Term ** N) |-> Term)] with FunctionLabel[N] { val underlyingLabel: K.ConstantFunctionLabel = K.ConstantFunctionLabel(id, arity) private var infix: Boolean = false - def unapplySeq(t: AppliedFunction): Seq[Term] = t match { - case AppliedFunction(label, args) if (label == this) => args + def unapplySeq(t: AppliedFunctional): Seq[Term] = t match { + case AppliedFunctional(label, args) if (label == this) => args case _ => Seq.empty } def substituteUnsafe(map: Map[SchematicLabel[_], LisaObject[_]]): ConstantFunctionLabel[N] = this @@ -377,20 +447,44 @@ trait Common { def rename(newid: Identifier): ConstantFunctionLabel[N] = ConstantFunctionLabel(newid, arity) def freshRename(taken: Iterable[Identifier]): ConstantFunctionLabel[N] = rename(K.freshId(taken, id)) override def toString(): String = id - def mkString(args: Seq[Term]): String = if (infix) (args(0).toStringSeparated() + " " + toString() + " " + args(1).toStringSeparated()) else toString() + "(" + args.mkString(", ") + ")" + def mkString(args: Seq[Term]): String = + if (infix & args.size == 2) (args(0).toStringSeparated() + " " + toString() + " " + args(1).toStringSeparated()) else toString() + "(" + args.mkString(", ") + ")" override def mkStringSeparated(args: Seq[Term]): String = if (infix) "(" + mkString(args) + ")" else mkString(args) + + def canEqual(that: Any): Boolean = + that.isInstanceOf[SchematicFunctionLabel[?]] + + // Intentionally avoiding the call to super.equals because no ancestor has overridden equals (see note 7 below) + override def equals(that: Any): Boolean = + that match { + case other: ConstantFunctionLabel[N] => + ((this eq other) // optional, but highly recommended sans very specific knowledge about this exact class implementation + || (other.canEqual(this) // optional only if this class is marked final + && (hashCode == other.hashCode) // optional, exceptionally execution efficient if hashCode is cached, at an obvious space inefficiency tradeoff + && ((id == other.id) + && (arity == other.arity)))) + case _ => + false + } + + // Intentionally avoiding the call to super.hashCode because no ancestor has overridden hashCode (see note 7 below) + override def hashCode(): Int = + 31 * ( + id.## + ) + arity.## } object ConstantFunctionLabel { def infix[N <: Arity](id: Identifier, arity: N): ConstantFunctionLabel[N] = val x = ConstantFunctionLabel[N](id, arity) x.infix = true x + def unapply[N <: Arity](cfl: ConstantFunctionLabel[N]): Option[(Identifier, N)] = Some((cfl.id, cfl.arity)) } /** * A term made from a functional label of arity N and N arguments */ - case class AppliedFunction(label: FunctionLabel[?], args: Seq[Term]) extends Term with Absolute { + class AppliedFunctional(val label: FunctionLabel[?], val args: Seq[Term]) extends Term with Absolute { override val underlying = K.Term(label.underlyingLabel, args.map(_.underlying)) def substituteUnsafe(map: Map[SchematicLabel[_], LisaObject[_]]): Term = label.substituteUnsafe(map).applyUnsafe(args.map[Term]((x: Term) => x.substituteUnsafe(map))) @@ -399,6 +493,31 @@ trait Common { def allSchematicLabels: Set[SchematicLabel[?]] = label.allSchematicLabels ++ args.flatMap(_.allSchematicLabels) override def toString: String = label.mkString(args) override def toStringSeparated(): String = label.mkStringSeparated(args) + + def canEqual(that: Any): Boolean = + that.isInstanceOf[AppliedFunctional] + + // Intentionally avoiding the call to super.equals because no ancestor has overridden equals (see note 7 below) + override def equals(that: Any): Boolean = + that match { + case other: AppliedFunctional => + ((this eq other) // optional, but highly recommended sans very specific knowledge about this exact class implementation + || (other.canEqual(this) // optional only if this class is marked final + && (hashCode == other.hashCode) // optional, exceptionally execution efficient if hashCode is cached, at an obvious space inefficiency tradeoff + && ((label == other.label) + && (args == other.args)))) + case _ => + false + } + + // Intentionally avoiding the call to super.hashCode because no ancestor has overridden hashCode (see note 7 below) + override def hashCode(): Int = + 31 * ( + label.## + ) + args.## + } + object AppliedFunctional { + def unapply(af: AppliedFunctional): Option[(FunctionLabel[?], Seq[Term])] = Some((af.label, af.args)) } ////////////////////////////////////// @@ -570,8 +689,8 @@ trait Common { */ case class SchematicPredicateLabel[N <: Arity](id: Identifier, arity: N) extends SchematicAtomicLabel[(Term ** N) |-> Formula] with PredicateLabel[N] { val underlyingLabel: K.SchematicPredicateLabel = K.SchematicPredicateLabel(id, arity) - def unapplySeq(t: AppliedFunction): Seq[Term] = t match { - case AppliedFunction(label, args) if (label == this) => args + def unapplySeq(t: AppliedFunctional): Seq[Term] = t match { + case AppliedFunctional(label, args) if (label == this) => args case _ => Seq.empty } @nowarn("msg=the type test for.*cannot be checked at runtime because its type arguments") diff --git a/lisa-utils/src/main/scala/lisa/fol/FOLHelpers.scala b/lisa-utils/src/main/scala/lisa/fol/FOLHelpers.scala index 576a279c3..402ad81ba 100644 --- a/lisa-utils/src/main/scala/lisa/fol/FOLHelpers.scala +++ b/lisa-utils/src/main/scala/lisa/fol/FOLHelpers.scala @@ -130,4 +130,6 @@ object FOLHelpers { def asFrontLambda(l: K.LambdaTermFormula): LambdaExpression[Term, Formula, ?] = LambdaExpression(l.vars.map(asFrontLabel), asFront(l.body), l.vars.size) def asFrontLambda(l: K.LambdaFormulaFormula): LambdaExpression[Formula, Formula, ?] = LambdaExpression(l.vars.map(asFrontLabel), asFront(l.body), l.vars.size) + def freshVariable[A <: LisaObject[A]](obj: A, name: Identifier): Variable = Variable(freshId(obj.allSchematicLabels.map(_.id), name)) + def freshVariable[A <: LisaObject[A]](objs: Iterable[A], name: Identifier): Variable = Variable(freshId(objs.flatMap(_.allSchematicLabels).map(_.id), name)) } diff --git a/lisa-utils/src/main/scala/lisa/fol/Lambdas.scala b/lisa-utils/src/main/scala/lisa/fol/Lambdas.scala index 2bc2a9840..bfc152375 100644 --- a/lisa-utils/src/main/scala/lisa/fol/Lambdas.scala +++ b/lisa-utils/src/main/scala/lisa/fol/Lambdas.scala @@ -36,7 +36,7 @@ trait Lambdas extends Common { */ def substituteUnsafe(map: Map[SchematicLabel[_], LisaObject[_]]): LambdaExpression[T, R, N] = { val newSubst = map -- seqBounds - val conflict = map.values.flatMap(_.freeSchematicLabels).toSet.intersect(bounds.asInstanceOf) + val conflict = map.values.flatMap(_.freeSchematicLabels).toSet.intersect(bounds.toSet.asInstanceOf) if (conflict.nonEmpty) { val taken = (map.values.flatMap(_.allSchematicLabels).map(_.id) ++ map.keys.map(_.id)).toList val newBounds = seqBounds.scanLeft[List[Identifier]](taken)((list, v: SchematicLabel[T]) => freshId(list, v.id) :: list).map(_.head).zip(seqBounds).map(v => v._2.rename(v._1)) diff --git a/lisa-utils/src/main/scala/lisa/fol/Sequents.scala b/lisa-utils/src/main/scala/lisa/fol/Sequents.scala index 1f13bf849..792c75aa1 100644 --- a/lisa-utils/src/main/scala/lisa/fol/Sequents.scala +++ b/lisa-utils/src/main/scala/lisa/fol/Sequents.scala @@ -17,8 +17,8 @@ trait Sequents extends Common with lisa.fol.Lambdas with Predef { case class Sequent(left: Set[Formula], right: Set[Formula]) extends LisaObject[Sequent] with Absolute { def underlying: lisa.kernel.proof.SequentCalculus.Sequent = K.Sequent(left.map(_.underlying), right.map(_.underlying)) - def allSchematicLabels: Set[SchematicLabel[?]] = left.flatMap(_.allSchematicLabels) - def freeSchematicLabels: Set[SchematicLabel[?]] = left.flatMap(_.freeSchematicLabels) + def allSchematicLabels: Set[SchematicLabel[?]] = left.flatMap(_.allSchematicLabels) ++ right.flatMap(_.allSchematicLabels) + def freeSchematicLabels: Set[SchematicLabel[?]] = left.flatMap(_.freeSchematicLabels) ++ right.flatMap(_.freeSchematicLabels) def substituteUnsafe(map: Map[SchematicLabel[?], ? <: LisaObject[?]]): Sequent = Sequent(left.map(_.substituteUnsafe(map)), right.map(_.substituteUnsafe(map))) /*Ok for now but what when we have more*/ @@ -89,7 +89,7 @@ trait Sequents extends Common with lisa.fol.Lambdas with Predef { case (s, p) => (s, Seq(s0, s1, s2) ++ p) } - case _ => throw new IllegalArgumentException("Right side of sequent must be a single universaly quantified formula") + case _ => throw new IllegalArgumentException("Right side of sequent must be a single universally quantified formula") } } @@ -215,7 +215,7 @@ trait Sequents extends Common with lisa.fol.Lambdas with Predef { * @tparam S The type of elements in that set * @tparam T The type to convert from */ - protected trait FormulaSetConverter[T] { + trait FormulaSetConverter[T] { def apply(t: T): Set[Formula] } diff --git a/lisa-utils/src/main/scala/lisa/prooflib/BasicMain.scala b/lisa-utils/src/main/scala/lisa/prooflib/BasicMain.scala index f7bcd5f8f..34f8878fd 100644 --- a/lisa-utils/src/main/scala/lisa/prooflib/BasicMain.scala +++ b/lisa-utils/src/main/scala/lisa/prooflib/BasicMain.scala @@ -15,6 +15,7 @@ trait BasicMain { } val stringWriter: java.io.StringWriter = new java.io.StringWriter() } + export om.output /** * This specific implementation make sure that what is "shown" in theory files is only printed for the one we run, and not for the whole library. diff --git a/lisa-utils/src/main/scala/lisa/prooflib/BasicStepTactic.scala b/lisa-utils/src/main/scala/lisa/prooflib/BasicStepTactic.scala index 678cd18cd..0501f1b40 100644 --- a/lisa-utils/src/main/scala/lisa/prooflib/BasicStepTactic.scala +++ b/lisa-utils/src/main/scala/lisa/prooflib/BasicStepTactic.scala @@ -446,6 +446,7 @@ object BasicStepTactic { proof.ValidProofTactic(bot, Seq(K.LeftExists(botK, -1, phiK, xK)), Seq(premise)) } + var debug = false def apply(using lib: Library, proof: lib.Proof)(premise: proof.Fact)(bot: F.Sequent): proof.ProofTacticJudgement = { lazy val premiseSequent = proof.getSequent(premise) lazy val pivot = bot.left.diff(premiseSequent.left) @@ -470,14 +471,14 @@ object BasicStepTactic { case Some(F.BinderFormula(F.Exists, x, phi)) => LeftExists.withParameters(phi, x)(premise)(bot) case _ => proof.InvalidProofTactic("Could not infer an existensially quantified pivot from premise and conclusion.") } - } else proof.InvalidProofTactic("Left-hand side of conclusion + φ is not the same as left-hand side of premise + ∃x. φ.") + } else proof.InvalidProofTactic("Ambigous application of LeftExists, multiple pivots corresponding to the unquantified formula found.") else if (pivot.tail.isEmpty) pivot.head match { case F.BinderFormula(F.Exists, x, phi) => LeftExists.withParameters(phi, x)(premise)(bot) case _ => proof.InvalidProofTactic("Could not infer an existentially quantified pivot from premise and conclusion.") } else - proof.InvalidProofTactic("Left-hand side of conclusion + φ is not the same as left-hand side of premise + ∃x. φ.") + proof.InvalidProofTactic("Ambigous application of LeftExists, multiple pivots corresponding to the quantified formula found.") } } @@ -1440,7 +1441,7 @@ object BasicStepTactic { } } - // TODO make specific support for subproofs written inside tactics. + // TODO make specific support for subproofs written inside tactics.kkkkkkk inline def TacticSubproof(using proof: Library#Proof)(inline computeProof: proof.InnerProof ?=> Unit): proof.ProofTacticJudgement = val iProof: proof.InnerProof = new proof.InnerProof(None) diff --git a/lisa-utils/src/main/scala/lisa/prooflib/Library.scala b/lisa-utils/src/main/scala/lisa/prooflib/Library.scala index 37460714f..9d64e2784 100644 --- a/lisa-utils/src/main/scala/lisa/prooflib/Library.scala +++ b/lisa-utils/src/main/scala/lisa/prooflib/Library.scala @@ -43,6 +43,7 @@ abstract class Library extends lisa.prooflib.WithTheorems with lisa.prooflib.Pro def isDraft = _draft.nonEmpty val knownDefs: scala.collection.mutable.Map[F.ConstantLabel[?], Option[JUSTIFICATION]] = scala.collection.mutable.Map.empty + val shortDefs: scala.collection.mutable.Map[F.ConstantLabel[?], Option[JUSTIFICATION]] = scala.collection.mutable.Map.empty def addSymbol(s: F.ConstantFunctionLabel[?] | F.ConstantPredicateLabel[?] | F.Constant): Unit = { s match { @@ -57,6 +58,10 @@ abstract class Library extends lisa.prooflib.WithTheorems with lisa.prooflib.Pro case None => throw new UserLisaException.UndefinedSymbolException("Unknown symbol", label, this) case Some(value) => value } + def getShortDefinition(label: F.ConstantLabel[?]): Option[JUSTIFICATION] = shortDefs.get(label) match { + case None => throw new UserLisaException.UndefinedSymbolException("Unknown symbol", label, this) + case Some(value) => value + } /** * An alias to create a Theorem diff --git a/lisa-utils/src/main/scala/lisa/prooflib/ProofsHelpers.scala b/lisa-utils/src/main/scala/lisa/prooflib/ProofsHelpers.scala index e612d0eba..adda8986c 100644 --- a/lisa-utils/src/main/scala/lisa/prooflib/ProofsHelpers.scala +++ b/lisa-utils/src/main/scala/lisa/prooflib/ProofsHelpers.scala @@ -1,5 +1,6 @@ package lisa.prooflib +import lisa.kernel.proof.SCProofChecker.checkSCProof import lisa.prooflib.BasicStepTactic.Rewrite import lisa.prooflib.BasicStepTactic.* import lisa.prooflib.ProofTacticLib.* @@ -20,13 +21,13 @@ trait ProofsHelpers { given Library = library - class HaveSequent private[ProofsHelpers] (bot: Sequent) { - val x: lisa.fol.FOL.Sequent = bot + class HaveSequent /*private[ProofsHelpers]*/ (val bot: Sequent) { + // val x: lisa.fol.FOL.Sequent = bot inline infix def by(using proof: library.Proof, line: sourcecode.Line, file: sourcecode.File): By { val _proof: proof.type } = By(proof, line, file).asInstanceOf class By(val _proof: library.Proof, line: sourcecode.Line, file: sourcecode.File) { - private val bot = HaveSequent.this.bot ++ (F.iterable_to_set(_proof.getAssumptions) |- ()) + val bot = HaveSequent.this.bot ++ (F.iterable_to_set(_proof.getAssumptions) |- ()) inline infix def apply(tactic: Sequent => _proof.ProofTacticJudgement): _proof.ProofStep & _proof.Fact = { tactic(bot).validate(line, file) } @@ -44,7 +45,7 @@ trait ProofsHelpers { } - class AndThenSequent private[ProofsHelpers] (bot: Sequent) { + class AndThenSequent private[ProofsHelpers] (val bot: Sequent) { inline infix def by(using proof: library.Proof, line: sourcecode.Line, file: sourcecode.File): By { val _proof: proof.type } = By(proof, line, file).asInstanceOf[By { val _proof: proof.type }] @@ -290,7 +291,17 @@ trait ProofsHelpers { val lambda: LambdaExpression[Term, Term, N], out: F.Variable, j: JUSTIFICATION - ) extends FunctionDefinition[N](fullName, line, file)(lambda.bounds.asInstanceOf, out, out === lambda.body, j) {} + ) extends FunctionDefinition[N](fullName, line, file)(lambda.bounds.asInstanceOf, out, out === lambda.body, j) { + + private val term = label.applySeq(lambda.bounds.asInstanceOf) + private val simpleProp = lambda.body === term + val simplePropName = "simpleDef_" + fullName + val simpleDef = THM(simpleProp, simplePropName, line, file, InternalStatement)({ + have(thesis) by Restate.from(this of term) + }) + shortDefs.update(label, Some(simpleDef)) + + } object SimpleFunctionDefinition { def apply[N <: F.Arity](using om: OutputManager)(fullName: String, line: Int, file: String)(lambda: LambdaExpression[Term, Term, N]): SimpleFunctionDefinition[N] = { @@ -416,4 +427,17 @@ trait ProofsHelpers { } + /** + * Check correctness of the proof, using LISA's logical kernel, to the current point. + */ + def sanityProofCheck(using p: Proof)(message: String): Unit = { + val csc = p.toSCProof + if checkSCProof(csc).isValid then + println("Proof is valid. " + message) + Thread.sleep(100) + else + checkProof(csc) + throw Exception("Proof is not valid: " + message) + } + } diff --git a/lisa-utils/src/main/scala/lisa/prooflib/SimpleDeducedSteps.scala b/lisa-utils/src/main/scala/lisa/prooflib/SimpleDeducedSteps.scala index 8e470c143..d9a2cd984 100644 --- a/lisa-utils/src/main/scala/lisa/prooflib/SimpleDeducedSteps.scala +++ b/lisa-utils/src/main/scala/lisa/prooflib/SimpleDeducedSteps.scala @@ -50,22 +50,22 @@ object SimpleDeducedSteps { object Discharge extends ProofTactic { def apply(using lib: Library, proof: lib.Proof)(premises: proof.Fact*)(premise: proof.Fact): proof.ProofTacticJudgement = { - val ss = premises map (e => proof.getSequent(e)) - val seqs = ss map (e => e.underlying) + val ss = premises zip (premises map (e => proof.getSequent(e))) + val seqs = ss.map(_._2) if (!seqs.forall(_.right.size == 1)) return proof.InvalidProofTactic("When discharging this way, the discharged sequent must have only a single formula on the right handside.") - val s = seqs.head - val f = s.right.head - val first = K.Cut((proof.getSequent(premise).underlying removeLeft f) ++ (s removeRight f), -2, -1, f) - - proof.ValidProofTactic( - (proof.getSequent(premise) removeAllLeft (ss.flatMap(_.right).toSet)) ++<< (F.Sequent(ss.flatMap(_.left).toSet, Set())), - seqs.tail.zipWithIndex.scanLeft(first)((prev, next) => { - val f = next._1.right.head - K.Cut((prev.bot removeLeft f) ++ (next._1 removeRight f), -next._2 - 3, next._2, f) - }), - proof.mostRecentStep +: premises - ) + val seqAny = ss.find((_, s) => premise.statement.left.exists(f2 => F.isSame(s.right.head, f2))) + if (seqAny.isEmpty) + Restate.from(premise)(premise.statement) + else + TacticSubproof: ip ?=> + ss.foldLeft(premise: ip.Fact)((prem, discharge) => + val seq = discharge._2 + if prem.statement.left.exists(f => F.isSame(f, seq.right.head)) then + val goal = prem.statement - List[K.SCProofStep])] = Nil + def cleanAssumptions: Unit = assumptions = Nil + /** * the theorem that is being proved (paritally, if subproof) by this proof. * @@ -560,7 +562,6 @@ trait WithTheorems { val innerJustification: theory.Theorem = if library._draft.nonEmpty && library._draft.get.value != file then // if the draft option is activated, and the theorem is not in the file where the draft option is given, then we replace the proof by sorry - // println("skip!") theory.theorem(name, goal.underlying, SCProof(SC.Sorry(goal.underlying)), IndexedSeq.empty) match { case K.Judgement.ValidJustification(just) => just diff --git a/lisa-utils/src/main/scala/lisa/utils/KernelHelpers.scala b/lisa-utils/src/main/scala/lisa/utils/KernelHelpers.scala index 122f418d0..70d404521 100644 --- a/lisa-utils/src/main/scala/lisa/utils/KernelHelpers.scala +++ b/lisa-utils/src/main/scala/lisa/utils/KernelHelpers.scala @@ -348,7 +348,7 @@ object KernelHelpers { def theorem(name: String, statement: Sequent, proof: SCProof, justifications: Seq[theory.Justification]): RunningTheoryJudgement[theory.Theorem] = { if (statement == proof.conclusion) theory.makeTheorem(name, statement, proof, justifications) else if (isSameSequent(statement, proof.conclusion)) theory.makeTheorem(name, statement, proof.appended(Restate(statement, proof.length - 1)), justifications) - else InvalidJustification(s"The proof proves ${FOLPrinter.prettySequent(proof.conclusion)} instead of claimed ${FOLPrinter.prettySequent(statement)}", None) + else InvalidJustification(s"The proof proves \n ${FOLPrinter.prettySequent(proof.conclusion)}\ninstead of claimed \n ${FOLPrinter.prettySequent(statement)}", None) } /** diff --git a/lisa-utils/src/main/scala/lisa/utils/memoization/Memoized.scala b/lisa-utils/src/main/scala/lisa/utils/memoization/Memoized.scala new file mode 100644 index 000000000..43afb5527 --- /dev/null +++ b/lisa-utils/src/main/scala/lisa/utils/memoization/Memoized.scala @@ -0,0 +1,37 @@ +package lisa.utils.memoization + +case class MemoizationStats(hits: Int, miss: Int, faulted: Int): + def withHit = MemoizationStats(hits + 1, miss, faulted) + def withMiss = MemoizationStats(hits, miss + 1, faulted) + def withFault = MemoizationStats(hits, miss, faulted + 1) + +case object InfiniteRecursionDetectedException extends Exception + +class Memoized[From, To](fun: From => To) extends Function[From, To]: + private val visited = scala.collection.mutable.HashSet.empty[From] + private val memory = scala.collection.mutable.HashMap.empty[From, To] + private var stats = MemoizationStats(0, 0, 0) + + protected def handleFault(): To = + throw InfiniteRecursionDetectedException + + def apply(v: From): To = + val stored = memory.get(v) + val seen = visited.contains(v) + if stored.isEmpty then + // compute + visited.add(v) + if seen then + stats = stats.withFault + handleFault() + else + stats = stats.withMiss + memory.update(v, fun(v)) + else stats = stats.withHit + memory(v) + +class MemoizedWithDefault[From, To](fun: From => To, default: To) extends Memoized[From, To](fun): + override def handleFault(): To = default + +def memoized[A, B](f: A => B): A => B = Memoized(f) +def memoized[A, B](f: A => B, default: B): A => B = MemoizedWithDefault(f, default) diff --git a/lisa-utils/src/test/scala/lisa/kernel/TheoriesHelpersTest.scala b/lisa-utils/src/test/scala/lisa/kernel/TheoriesHelpersTest.scala index c74f53614..988ead998 100644 --- a/lisa-utils/src/test/scala/lisa/kernel/TheoriesHelpersTest.scala +++ b/lisa-utils/src/test/scala/lisa/kernel/TheoriesHelpersTest.scala @@ -28,7 +28,8 @@ class TheoriesHelpersTest extends AnyFunSuite { judgement.get fail("Shouldn't be able to get a theorem from an invalid judgement") } catch { - case InvalidJustificationException(msg, None) => assert(msg.matches("The proof proves .* instead of .*")) + + case InvalidJustificationException(msg, None) => () } // same theorem but with correct statement diff --git a/refman/lisa.pdf b/refman/lisa.pdf index 8855ed46532f486aef780ff64bb619ca8f1a58e5..80036345874145be30b7dc8a7edc9bd947f413f0 100644 GIT binary patch delta 210471 zcmY(qV{j%+7p@!Iwr!gedt%$R@x=BM+nLz5ZCevfY$xYE=ls~;{@YdERlR!Ey{_(i zH834{wgx$o8^9wZ1n27JVs2~?=d~H9GBdl(g3$ed5fB9RL*YSQNR$W?g|FfmIpk6G zrAXlQ1Md;AUJHR%SN`Oj0UreX|sM` zfRuta{8gC$!Q>AzB;FtKB#ZQu94#8XsCicZSAbfOLt$I24YMY$VXTa;{CCm+akP<< zKsthZF(T%N?%tu@|9I3*KB?p%p|4EUDzu z5|eYi%eY+P?r`4~QWY%vmECwAffQT8d$DAlPc;p%F-4@GAQ0~R8qD4p#JbX}sK8WA zo$%qO`jrm7xBCUvcfVo)R5nEiUV~DBvH~%|Xat9>%TXZxxm_W}zy;;N<;21gIUw~_ z$pyt!;UQJg1?AA?!V*)g@WH{GD7w~Bm?76t5WtPxNU%ZdMQ|vA{$P9nPVWCb_bZ*L z_zNzCofrB~@M77Lynd1xuq((;Th^|k7%#T-%9!UL>{RgyuA0|TqSK{GFv_0xHo=LH^NzS#0H%=060RcgKpKGsTN;0l9aom!Fr!>GK4eir$C|f|As4T>L?W8As`JQ3Gb$}l&+UI+z-lzVFa;2&Y1n#Ri+~N!$ zFlb2?1URb3QR@?zpIqyn$3DB0pEqy%nGW8WP1(8H1$B;Fd`Rd;b+BMgI%R0}=OCMY zNF>WiZ(LkK&o7pbeRp<53Lpg=e-0AoBswPg8y;}uJTL0!yBL<7_;)QD%fVPJ`uTAd zj&71xvXfFco0razeoOvRNr^Ai#k@qIw%5a5a|%Y%YGZvZ>#caJzo_SSb-Lf=1C-%b zvTJDqz5TRNRWNAi%xed^3)^qE#~J^xeK17+r`k4ZGo@MB$_(`l9jQHv+WPocLqjVl zzC3_Y<7Oxv@}MQ#^hm&Hr~;^zuMr;r^j?Vtzb`YpF#C9Pv|Os&I5mJ#g4w=cW?az? zYQ>DFyJE=1<9VQitqPE#n+$EL z%QpE6H@YYIIOzEZszTi*)I4ed!aAai5iS;@Qlod%#8KMHB(a%Gq{^rdUO#?8t^?dQ z{JKUHQ=&5SPzq_&*-yOXKO3Ap&Ms6_o7H!TiWQ%QHdSghOqRd= zW~@LpW;C4)&wpeRYoJ9;nIF4wxBxtq!7l6|@{5nwNp!lAm=%eb74<#|IZ2p$%ktX| z1VY9IMG$nsex;_i_fHuKvm-x=ie`dbc&gWkIJ+==^NNzfV}VJno-QbR>zA@42!pfc z9~=v&f;f0vSCC>bgT5^w;jq3eshkWvaZi7fXS@=pA_j{aPWb6LF^O3BFaf)RXacjg z`^x0w0=20&b197~F*KGEw6 z0v1#KaUkHF7*kj;tl9qIPbg1=`gr-IK!057Jq$NBxUNA6)WwVT3z9Kcwdf`NYXgFc zLhb9ks?4!AAhmc-uqs@VNB)(}7rR*_JUvn_wD|7W)X|=XuHul?Ea4cYp(P#2t|Eft z%tm~ee)A1VPCJ$amrl+IjtU%trUCrlI+!uxu*HHBe&Y|<6R3q0L2q>Sy8v-s7k)3A z=#uBUBI5ZAIro4pQwPl(c9TpJC9+K1ndjjyzc9-Xkt6xLz`1ha3_^NK;JYLb`u%6Y zP}nZ}C0`HxKOrmFAj)2)0UhO*j42Rn67<`Wjw<}<{gMYHfaM9rz=bYH@1_u`^3%qp zs0hni3nGRT+LQJk9z733wccEaIeg}|K>a6O+_Lcdc|38))~~4_wU8AU?zkoS98E#B z>UsQDHg5Vck#-qHThMIbwONvtk(l#1+Jz?;Y3ZpPPOcn#gc10`%HGdDEIJbU0idxo zWUvU$xt6S;$qW*0_F7}$v}I7bO0K5|>f?X>{J`1z;q153@VbZ)XEHAn-Nh(5aM1s$ zIsgM)T@HE|xtyo@LW8k(`^WPr>v~{oHPDqiE};O@1sE7jkQ9GV{v|oVMhJz~n~78T z8F~nmvJDZU!RqKsLW986U5>Z%!Ffyv{kmW}pZZ7MWmz}3yf}MarI$b8A^_ngMmm*LUu9kCJraxN_?OrOz z{CokxT5-axG|qv68eKnb`=E>-I{7(-un}nOL9)}a@`g6dtVy-z^-Oh|a6qP#$GxHE z0%c@4o9w){F|uAubbT&Ov%pT#6?>2T^wYx(2eQ?!ge zl{>SWf4dDGvg3OsS@z&BH|!ykkK|xoFo?4{07_kMFgEWhze5N*@_ua0kNOQ= z{!--!xuAnkNuX`&?T#<~s=#K<6u}WX7D6BQvurhr?q6V6-c56+l}HyvB98L1(^h{Ptz6Zh|iq`nrdr9acon;+`=oeU5uWR_#wl`lB9k zg~dL(zj@!L3cYq=@T;IV!21Q-bRd2U*aFWFVEbQysnMRQ#pnKi0mdSeK_Kec|Vi>&wT`)cu!|H)zu+jInnIb2&&AqV8Ku6?}kq$Cn2eln?;-=z4U0ZWO{% ze)<@9vaTaX56)aNaO#Fx7(L5yDa}rT9kSf0E6%y7v;~tI?|loK06_1hIUp-i+&9FrRRUR&~SMM5#D7Rh>+ zh(8&q#92X+FDlw%W*%V3gH|#^X6Oe*x^eZ1=SVUcs!n9$84SUbZ^jI!XA6< zy0LaEFn1H`YK6QYBHCBc-N3sDA{$CH03 zwdWsGt?b2OL3+|{PvckXTk|9!Ta3_Y^zeNiiH%Zex!VyA$o+{>dAzKE znny?^M*qTo?IFP0UV)bpTV}}UOkNBWbep$9!s?o+^n-q;--$(FGK<>CEvlNPDM`?7 zNhV$^1AVjCF_utLIGWHEr*e!`J)U#RRoG47On{Fi#`fXy zCog}@;wiYUd^Z{|qH+pMWZHV!41Jaf8s?cy*%<%kBNd?ODgNm%J*nJxcE#2}H*|hO zqtEZ}U7m?|c2cR|0&0)X4%u&0;cIs0JKBd4-CPpdnv}JCa6dAfDA^d}AUxc`v*5v3 zbFz~RuK4VSOGEO(RmT+n99KFv^dto3jI5v21d(L zuaNVJ*UQ)kd1Cj;6#%V=Ag)jA(XKkLNbnFsuN_bXwjelegO-|%tEZwoPBUU?^{wDd zeNrw6&wWBMm1h^aGA6LbH)mB>hL%7|8+vT)vJ1$;n_;(>!1d4Tyr`xT&E{733z>(E z%aTjH#eU)mRNn11g#YXOLR&-4JdSa4&yfz2oYhSrr6>zmxI|64L(A73XKyS(&8#Lk zS`I1L>rjhvgidBhsgS+07HDcD<5zQ2xQ6@?1$H)uKa>M0JsmNvSS#MUhu~9yN0?}X z>jp5vf3gh{WzkF>#Pd?Gu)g+>@cpd-lltOOLJ~x=-7tJU=M}pj{#RMb=zjM^-P8M{ zn$=j^f4x(dU=~FLA7Tx$T&(D9seP*Z#0m(e`V9V>rU=8DV54;H72tQkA7UtUOAL6J z37nDBab=U9Lozu>f^!vxs{*AJYrm61aR*eeu=sYV1tL%aI)*&D5`E0FyELnKxt;iD zZ=N>JXvF3VCvul63R==lT-qX*b2=1Y<`j6=2eA00ownz-QB7whVYlh%F+Ve*%=F z7+z^8TMk;d$!f-Yu@AQ^S*`tX*f2Wq+iQEy$|$AQ$Y6O2AN&W@vX+jcOfU$8LU6Xw zjgNPxATz``9yAdnb3q0qTnani0I2OAfVH(wmmEQzmCtZqDb@f zo&xQVOtJ$F&^>$kYL^wgd;vf09I{57NdH|Rz0bubAo#wm?RVtd^J@-^Y*&lntH19G z^cgx>8KpORy0&4JE5p0q^$NEzJ9bKqAZ7uZMl~SfEYlFKeIeZv*b)M9%@~?D)rTeU zu|87~Uwk%x7vnU28@3cg^wo{zxPGLyTD#xyK`hMz~9ZTznHV}Kkj$(2sKEY!D7 zfWDB5Gpq+}DX27Rm6u^%kkgLF_c}L7^DyI9mg!^r@W{$~=kR9mQg4&?HFDg7c{eF@ zjZoRR(x4$5Dc;C>2ncE5fEUl4()AyH*zqfLLyfYXbxvphtzuZ(i5B|X*RC)>cK&ZZ zQ5Y3?HSS+8tlDuNI|?jumdAy0h(^D0;;*)Z=J&l4eheHMVPCM@R4#N317wF#Is98= zua1kib}8;#n|{~rR1Bu$rb_&sm2vPbkw!~9%NT0OOSkCsPQo_;HllOmef+G8rbWg* zZDk=_gfR#fZHfAQUK^%@A4jF%;eeq7u`p;r*?__r6wq6a!D-sop**U>E4P@}v+&8%URO-AtWp1SOsT2`h0aFl@0fDv40S`7PltDJk5OaaQ zn^8u1faqmgfSVq6LhWki{8x*kZ?Uq!bGZ7Yo(tOW2?y0|)j(0^1c2jKrfC>j-D#n; zi#)<-!J|dcqq!oi5!R07?dw6h9CFKABkZu}6*jdhJx8lMfdQwk>rfRFY8}Kz^@Q5FiagsJ|UQ;-vHw@0(3hJ)0R=JqW=fF29d$h7(wh|nE z)`h71D#&ejkh`;#sgL=f2D`FB&?Qm{r@$`3$Y)AX&l0ny& zo~ypH?tMR3PgMO6yAl|W>n>h%#t`iYJGvU|6mCIYt4-~|3_ws_SRk)W3eoS$Mold{ zi<}W3C4YI#Ii!F=+zOPk4n<_FxbjbMpExeT#T~|wep-rP&$SkXfxAC*eoljlhe0MA zW02W|j~?mgGcDk)HT|dm0OuD0l9l9PO=iGEttU`0`R#=3;#TqC(jC@p z&usE6XywN66CiLlj;Y;VWG9)6Qe-?$5v1NsV1;4s6>WlYSyrThQLJz=meLWnq@nCN znK#{j^)KdDih;L4lY#z?E0g-Ld?6OaM%dritjm8DHcs#ekr-dJn{@r|ut>T;TMDSX zcOkFS$SRQGxMI4G3ZiiZ?aVEDl8aow^sPElv}+8^asel(!-U9*E0mMJO?AHtD&QYF zmSkj8DDrcmFC^VSH?wYyW;mcKqg<_%=}-dltVVHa1lM|Dmc6zcS}`{C{W36cJ%YPs zn5lIg94>ck>LFj{S9A#EYx{L`{t)Z|(Zkkk!(>u}t`c9kwRbu9;1RaS-ec7+uc~T8 z%Lb>(a{;BUXw#haYK`)|J$ZO^&2}@x9h3sUQ>Lw+>MX7x{;?Uar|nvsb+uLgC6ebr zrz?;SNa)hbANQ>aB!Bc7vWk5Y5MB3TLvL4x9r<=(F8_ca-kqb-1$ z<&4K!pFf9mt})u`e0}~dp^YbmSEyv;e3x)0T1`YQ*vX`Hf<+U{YSa{OUSW zBVL6O=0z1vs{UDt*J=9D*Z)&iau)Dcx2Li%?AaDvp^3a{9h90N4$)1MIAq{p%e@^j ze{ZC@iTKsHNJh4c5NS4CrQwYGHjJvo&xI;NXS|_SlaREW6)0fd z2>_5*UXz}`8JDAGTiv`z+r;k}CWw8ga#A2*7WcKN9X#qT+1VbMsul1Yd6ah(Nb`~; z+IqjZ5DWs>(vVb3&&O!pELkcuc23Knw{mPjW3GYoQtBMXE*xeTJ9v4acXBR~J05$* z#Lg$Wn{8O%f2edso_-~C-#>M3y$f;M7Xu8|*C4$%V}KCo%@MqSE=|M@SRdR=YWO3N zhmKC>4J-?(uJ-=d;CCR;6|MMU_E#6slyC{;|m8p7A?HZvjxG zeqX%&a?(i^wY7Vzo7>3IG4=Fyghq;@H%*M54#Oh(?t+~znJh0WEt!mZq^=MwXdvT5 zMrWH-LL+M$1;13Ph9&&VlP6(y0Qwy1D{^4>0*SK0aP=oKmUW*eOr}ea>!;SKq6H6P ztL4HQf@>Dpxb7OA&-tEU7H^b5e-qGLfdKdCn9FO4L4v5(TzCEHyA&QF3rx zysf7Ly1iU;Q-z~$Q9nzqKicgph~0qWvWrb~=uLuXJE}XAt+vHTgI|0yJ5&4y3`HKz18S-kqQvfi{ES? zX3;xu*e6c8dDE%cKQ!9S7qlrg0^7o<0z7o+)4B)c=tFk1SFXMq|H-E0`XhdiQ?)b!RUHH^}$+a?3xEC=yNhx``te9bhSmzo;|F?8M(Tw?ofh6eEWN z^N;~+{9gTJ!50$HUWaa^8-P>4w8t&;2yShb|JB3D2k#!d~D<`Kci&=`vHyJUflcXlhS_O<7JqN{3KDk z<*W-u<(}czZlL35`kf)+_j|qL+xFq|Gy1o0ribzY` z4^w;ph=Ca?FB~i&kfB<@J^f2A_~^w(XaSdGyyFqoGiQXz&mx z1aJ!RkX*R5hdJ}YeCLjuY9Ky5`J&?ny9_+guCxPAWZbAEBLqn&-?3#f4_mSOEF*6BXl z1?x8T_e>SOmu2qFN}M_hi0U0~>ki5b1hkgGw-p=S6*xGCeId7284hxlZM@+(gv42( zKV3;9sT7s&9a5akpLcH_d|WukmQlR?EFY;EnZ5Ep@<0Nk0a^*ZHFSALq$3hmt}P?V z%Pc-}-EoRXW%KqNw_{_A3$e66T2WRkGbr?OXi+HPh)YaaKJ6U>&#b4npGB&+(WV~tx5U9`$+ zzIsJ2V_6``u5y*<*xn4Q7l9rJsmXn>oBXd^12TiNa0g1u;E{#BL~UjQdx;0N1q}w(gOfZgZcCpTZF zs#L3aX};tTgDf{(qOu5?j@_M{X`V(CUzz`chhCM8QEISmjH!s1zs|%Ypc@z{_+)hC zSF{#r;+pC%@q5D>4Y99lWqY(Sz za2yZE&jw2#G){o!RfIbRSZu`%%b0gembSGi8NDE}m(e|XV#+q+EOtfLA*y6bOHaP2 z4$|4UexwI}4W{#R+DG-GQzVgkMS{1I4Zljtu2=-`?6K=XBe8g*EHFg7D)d~%Rk0`L zS!gx~w-!N~FI%=UBS$URlm+u8T3l5&cI{?q;{S1`x7G&V33tH*Xy)BlL}8Vd{jp0U zMISY?+)4V`u&dTa6#h#W8C<46>}0+QHPE?FcNliNr(4lkVfFPdPGZ952wq|U1KAEq zW`VD$QHa%H2O^kp>7c9wnOjZ~@Fa&HqSm+-RZ*>zMW1pGATvxTm+vo_?`0EAKMu6y8Q_`O0D!AaI>@0?N6j6 z$YR)}Us79cVW|a6uGH+>h==QaOn&RFt}{W538^0@KwfJuI=%DkekG*65l<+EzOZ91 zU;5xV4MI!fwX;QgQm5FE6aq~yE;S~8~pU7d$&>IfS=8OSz@7Rg&mXMl&!D;Sk znsdL&imKIK_ zl>E5^7wJa^5G&6vSZQ=)d}8%Z|FvK2GXzpCnlozesy2ZMYvCTU;o0C$Mo$&xD_to_ zASZJ;d7?0h|0#5gc+l)lku(P-bF`Y}I=@b1TpXtx!rZd`5|hh>a@^^xICp*O0gaop zJDZ9H`3ghM`_2W9wHkA3Fb^}QH3aw2rVdinT;Ze#2%4^RTOkzE5o957YhHC@7qGK$ z01ZJwvD5Idz|A7DZnMx#s^!c(5cV;xVk6NkR=VvYyw31^O837s>i!^6;&;{BE&Etq zrzFiqn$Df8x2>|x)RNoR8sf7L_BKsq&|DpfO=0sEBbcy4b!MHZdZND=}HrLJDXE&ux z55}2Ygn9mFgt&WbMW+d)%nCleA~pMrXyiek5i7uID$}-U<3VQtiAPpW zPh+*8lQ~{J$hM~Aq7)Oen}K_{v}zI!Syo1X8=Faz^mzQxxOb4eUZfX&`943KQZECk zv`%xwN=9c-Y?K?NVHcw8m!xZZIq}EKnBg~g^Sm(U|6fLZ$f*Hbod5gcoT@Y70N#Px zb4vdXJ)Fo;8@MkPXco9lb;me9(0JKlh6I!g5LTDK;%@0=#0jR1{!4CnwX*rWK3#S< zXSd*hRK&(-m*00Z&iwjb^Yt_J@qF4hGGmqM&b9UN;&G>eo6mKl=Hczz_j6In*}v7d z_ahUpiWut}*8&IPRL(XNu)oY)GoxUOtP>HMkJ$SY(6uj+bHLcUxJ5Y{nIBxp>o{R> zk#*B1-ei?KbhAxe`%}=uL7v4n*%iK}cx< zSSt}C9n?4)L?Bc6d;DJgsA{CRis6W$_)u4EeETgmW=mi-Lx5|pWcZ5I&nVPTkVser zjZwO&c&b^^qXi)LWIf1A=W&y)-SxUc`H8*_lfMQ$+N$-rgioK)Qf2~3xacl+9zK5k zChbC1(OsOo%~?cR;1LQP*WtCLf>C+~)Z{mY!yqBASXY5tb|0iF$PW@Q$?q|g2Nj9yH=UvKkeyjzc)QPILmG0x z87pi_6p@!PNkL)pU~0(8i=B-)3JX}r4g6H_2ocBw%C_id7wK|G|0pH~gvZ+cN^Qw! zb?@JLi~Vst#$@k_7qA*4d=(l7C`4vo1;Z=rougzd2I)#*=Y0OvoEpa+TG;=M72aoH zgmXkoRSr~bnWXfby^ZXca(d-4YCl5CAwDDaGiAHzm`s20~M*)eAcfpkMZWmy!4KyI~K&x z_#CMyul^0P2_EMhkp7tjj4P@ql!@{Zi3^AVOH+39CG!66HKbLUyV9;q0b-7uT;q|@ zC-I_TO%GHicU9^Wh2{;k+LwFUiE74LYH(3(l4ZDT&V#iYAD~J-9G2`l>bg?9bo;Fv z%HBfJH1AKr#KApVzBo zzE!EpnmypSt$v@q8Il=0j8k6JwiwJiu0(Vb{Lg~8ZcwWerXcS^UQxK07HQX+4?@LQ z_l&Nqmb;ZZsmyL}tMnq0Mi#qn2R6#+s%<*D1>96!V2R3U)3G{v`4!Ves=(A8>XFejOMlNPt=m7Hci^7`dYPZTg z8EPf|>df>bfw~9WUg?|W-0dArJ(+E_FZo&zu-a38zN|S5P;f`ic&4_%+{#4LDShoA zs~r6O1~w{yvzWamzmd&dJjc!vt*+~;=@#CY_fe&Ceb$(l`(nTP<1wr4gH-Qwb=v&0 zvxQ+;kX~y7&-Fe6e?>r{13AkbS*Y8TH)2$osFM8#254v^pB8WP%s^3N=?PPqv9@IA zE|GbBhNR@6@`0&8cYF9_Iqo6aH9CaQ`Fy z^uzYa-7z#X1$a0W1^9p6$@T(=vUKzGh|f|0TvN92L8J0XuzHoTzY?Fy?$#Ok#-J6P z+2gw5w%k&@T{N)bZ4@13U|fCUGIu>&;{lz4jV&@88gCCFOO@qzwSG{}@H6rknVUyS z^z2hvylppjQTuZF$`&RfjScVB6hibvI8qng;9QNm;KT_q)GRsSS3FlWp6Y9xi(Tc;vbga=$%Wmmxmlhz*wg+FltY%8yiP|2d83^3 zz;S^<9oy04VZ-ned)SEDKMNC(u=(#Cbcf`IyMu=02E*eHfr>0-7l@#1T%x)B?U<{l zffUT!>ae8@vL7Kar1`YdobTKj(+ht$g(E)r0dcbSJ zWl4x?^dXmOb`aEiTI$BSZ_-QwuB<|C<_{hV8wl;W66}5_{LQAKLHDx%8)0s{SHch^ z%6?}cyJTu<87sRPi@augs3d4E+tNrO`gA>Vpsa$R+K6B}%U3d9Q97<7zn+y)&%MYA zb!LLS=y`OTa^ZF5)b>cPBr$fxN`v^Q8z=Na z;Y`Q7Y~xs7v00r(RcT~EtGu&8pI|sBY>c(M>+U*}jDLDFzZ|_$6(NCC?Sz5K_dcfC z@aGYL$`=2Vj(P!x0i0%}0dV~<8II^p#FPI=h9C6zJpL#%{;YWJEJn!tz_IJ>u|P_5 zYo=PUmyw4zq-!}QHCZ)oynianvFW001}x)|i;wPP=-~h}6}Llq(%@saufVkYgD2hh zw^QaN;vd;{aTd1q#Pcb8KG^8UdEoxI6T5%r&l4`dRP>;fHO=zl;i@DhSVLmJ4S$p% zK=ul7Pd|G3>0uJ<|6FrPXwXXC+Ox;el05iaf0KdWGWnAH_iE4Z8%n1_g|-X>Ejf7B zfcX2`=j&LG2$gN|d+Z9}_C7XeKh?HZR);PoPtWy*EJ>TVZ&E}+TT`A8#TrkO-f+;j zBwP+KL<$<~HKZPn#X7*9{>2s=7id`m71dsLfa?w@2a2n)ukA5QSZO`i3ALK`OT#y< z^u4v?JZJ#ojr1G8D+-r?dZWt6tui#KIK)(bceN7;eM%!9(2h|D@E$;Vw19Cw8+UZM zMa7`iXF$P#&11++mpR@nUESU;ZiAYlpfdn2aPgt0_4T&Ex^%v3I=Yl*-*6|X5b>n1 zw_{VJmDy2QM2*bc*fUpGy|r_9vKVB45`t(&V^m z=pgruoB_R{1hTMT1JW(+;bOH>HE`7DZ6cL1_ftFEYAVUSrmMl$Z7=DpH?=lVhUog~ zf#*7_z5A`!xpq9`R?W4pFzB|-<4M0MB%}OW9TF+SA%$}&OqD6GMxT;j6g zF!Hio25@`~7~BplGhi~=ILgk)B=V63HW&7Wz40J?{Gq80SwSB?JP}#&3T$dRaF34= zs_HOoazn@=_pp&U3J*wcT$xGxP;jdA_MxhdjHf@$yOQkbcfAN9=Q?vm>7&Am^4QopTnc|?M z{#`0hb!F)`&nPuzIjSNDO3N-CE>8yHvscW$XK+QJhV$w(y0L+pPaucwuWXpA%P1&O1h^y?#LnV~J zwm5L93kC7YCU}d73bJTK2=j%b@6zD3-B1!7fq%2N%z+%h)d~4R>V|pnme#Pq7#gN_ zN7o(J{@b<%eGg5GuYQ=VA5mco)ggI;^fG+9NQ@IwmyNYd;fOYC@=m~Sw?&6moyhA5 z&@@Wm4gYCj|6aaZdpQu|*zdbA!EK$L4K;0Ma0AxY5dHnuM&0EJQ3hu`f0Mbj2=#a4 zV-f25n7eG|0ctywD{}8)HKjj(I<*3ac-nNHQghTX(r-*qQ|b9kJ$=k~MPGB-;{XCm z-_!gveB5)}%iZh+XYR64g84@6=D#)+k;vbh!P~pwkjH`y+%RDAP+&ONJS6A5-E#H) zZe!>lyS!N1tY6AyFg#(lI;@oP7dT}YuZW=U^5>I8X0rXhsL32Sl*Fd8koP#Mbde9{ z6DjP&AKX~abjL4DQyCjqO!akotRY-Nb4ox#4jj^+NKTn8$fVKwvVO<$c}oQ)j|9%- zp~BR$7@7whTe`$Cpa%ytK}-g)SwGPl!4>W^9L4|S(d;F|RBq8pfRp8`892a!4c0Rb z+~mLme3bMeb}w{y;=wDJ) z+u4jn>o}d331f9^U$oWcR(D9KH@U%2`hlxzbl1iP3Yu`QZGuZFp&}ExT>g7Z|9&c? zmNsJl`og(8EJ4gO6||G!mtXJKusQj!*}OTTl~Px;&Pw5d-C*l+>5|QVS~*6>9o-lI z3~Orz+u?JYxSw?p_M^q5?(iYBJb_D`j-Z!7F)n@3C}1HMA1E?#n~MN62KdH>59pZI zL%eshs15h^x2O%+jhxntd)5ER8$jVvQhyO%5Ey0Y?RSjaw)E3{COHD%jls!p*5?Ug zjb*;YCwsx&1MZl1Ye<(?--Tp$;QcMkUV=M>Happ;far3ONMWfGi&W|7KG{2#(R{>F z0Nb|JN_Nw~wSbX)iy8Bw|id z6^BR8F>49!Ek4_$_EM^#bavni*(QZOwmjZYHdx<*SU!*7hTzF>(52xB0Ob)*{lpnv zWz@g8hIX(%){@>4cXMPNy?)=M5lVY(NuJR|xX;nVcdRwwP7_ZV>PY461mW`v=D2BZ zXK)}-_;{7Dm((6ZMuO=l>c)p9nh8Gs!{1_%R!xZAwj;l7rZ1oPsAxgb1cHvfnY)me z8_hAL_8+h$543b{^zV~>fX`T55LTqoipc$&w-N~tn!1jV&J2!J;sL(T%a@4KV*&oH z6Z1Wo@>-Z7&JhHgpV(C|@>%3{2S`xTto7Tgl%HDan^qKs65!l(C4FU>kSz8%r^dn6 zvwwe?FMFOYkPa-K@sP|eX8KF7miZ;2j>a>5m3?ygsSyIhz-NmxbdZNA0ZL!uimv@;LL*0Ina>f#7FyOX{4|3RL2Zjxx%h|P_p2L6t1Q2 z;kd!^Mwhho4xsee@b?@?1?v@Y?Y-o3l8D0mKmDKuw!-JdlbQ$ZIn^jl=3TmTjc&uqwpE7Bzo{udFl*@tmUz*4L+-u7}90Yolj}YhXK9A8e%l#5A>N z>zkQN|KU_>JL@r_}CJm7mv0Cra3#pK;NdpFi>uzkYnq$NK< z?;G$m+mVzr_kFY{{Ef5|R`eB?B2Npst)lrh(b4I`q$pCx(}pAj?*;hq3JJ)}bS8Fu z5E!DS|CNtSy~jRtH56tLq&URx5A{ALg6}g;)*@NEHmEGYhx>|~XD|u1E1k|`3=p(r zB8$Z>e_A6(J`=a0`X!h1=ZR$;(cu0_fe(PaZV*TqS*5i8FGPeTGV4xN4pWEYkJxBh zKdA!QBiz*kWs9!CC``WJLxmHZscxphK@=ZlrW!$zEQ(n&w$&ZeQdmICTn_J9Jq(f* zkgnUed@#lp&Fh4Cl&ne~XICzDSCg{zAcjRi={9-TVWo&!y7Xjw?6fb5sg@vrHxytp zT2S%tkt0s|F@GJpX=&2pVbJ~eFFW+`v2Gfo(&?tGBphtAC&Z@zY)h)a;L-q|IgYM+ zacT0|QYE5+92G$7$0U066#h98%C5x$xo+;N0W46H?~GLEfR?eWlT_akI&+KCX#yN_ zDK7l<1Cw?)WYZ6fWHKaFh7od>#uxCfs{m;Zcz^F(IlXK;1=A0Lay7kmn~(G}aZcR# z#Mt+p5ug}N%UyNew-1IeJ>EY}0K9#)Rgq<{u(y7jdz?Fe`Da9Il;96gl=rs0r=h!l zoaTowUdEb=eeq67BbzYaxYRF^o`us*!?=22L7&aJ%f|R}<$Ga-o9UlQ_696t@g!A_zlcY-S@EQMO+3JmaWVoWWfe z+4wh#K<`^Bx0f{yvYPkM5g5Q=I0PS*dPI02$jgaj?ZT#g-UWUa`BzaIJ_|Z28?5M< z3`M+gXqD_0DTyEjoBj9poYM0QbS}p-1Em>M=mb&(fi8z!SAa z>XY=9YFl?3=}xeqJH(MO1B>!q=xUIA{#ViBUAsQ};U#&-GeS{h8aN2UR(ERtoBjb@ zdwe_0O)+)@Vr{;7c&72t3I?urVFXFYe{l$ij72>bGBb0i6O}}58Ji>>C)w7GAto~w z@rK4tta2TnWM>n~{{@g7I-)h>AP`cLGxPh^9iZw>pS84#f#MR?1$~KcIeuPu`*N?J zGELCTubN_ZOcabZ*wgY&Dl3`t@jJPr2Z~Z+nTR{0Ak@jR1`wGHdQ6zoZwPNA`&{v< zN@MLM5SAPsqAZsJvefQ59Qlxpa(LQZUSf1DQo>_(uRxWG=?8#OfqB6K6)TCQc_F2A z^+i;P{v+stBno%1OJ)?A^523b(|IyM&V4R>Ev%0J^?q$?VO^o%lW*&8;cl)+y5z^1 zJJdBakl8r8N37!<>~7A^k3yw*+D*fsm_?n;sP48O+@)|k@QC=4UGkRBocRxF!jlTg z;5yv*lZ`QurU5FF1d-qT?{~W`rj}jTv?9E|_#Cw~Ux8(LyLGb$R#VLvmVGXjiHqM4 z;OD&|Jis|dDgQUFYe-Ld7qOuHt7DXX)n~?{h;icN>ky$vU&QCC`W}8Bh|d)Nn17`2 zQYD`I$RwsZHq8dPeYz>^=hY-?i^tg`P5j2xHr;7a?|>_E9Q)9^Rvaxzko47e_+2e9TeT2*~Zo_ z&G)o-)&T-iCHyt)4ZcavMb+@Gf}>pYAG3#}WxOOkmYIv}^mp*4{yW52J+!m!O@dW8 zzBA{Tb9tSPnyn^eTD%)~gOPu>N)gx->EpO*zwQljK6G(g7;v*((0ta~mg|*h3Z}7VAf4gC8i& z9q_H)@YWqf7_Z$>XrXw(@xGYm+^;pYU6>+4^rhIhi{A=?d9cSzzfi|xG3YZcBjYk4 ze2Jv-e7p+kOA!U6VxS*&Lpf72a~@ERrRhy(<&?FgyhJb>B7N@6oCfq%3R74V&#kH_DPdL{@k5k}0U z_kazWC{otJXrh=k&q(+|I)NKVK`;+s^dDi354yd%74kq3+sut8eeg{(rCDV11N@)y z{}LvC0JOxq0QldZK`A(b^$i~q=l53gL5*s2U%SL|=U8*J@7#enM%Vv#!N%T)t!gP)%?P+6q3auDDXRAh9k`KiO0Upymr~v%jwI+AsWkNX#f*Hk9Xm{ zue$as3$dUfvkXVm2C!MXNyE{?U>ahvP`EIFrJ!w_GiUO~--9@HvRg85G@(_9N%vsV zgHabI(m)~;qvetklW5YB;Ol5RlyYJ(Gan5ZB%!0+JK%K-;pL09+K{N$;+j~l6CUas z`7q(G({L!az}HIQ%}_Gv@}HSiJyB|{0bFcWQ7w}_Frpoq1Smyw{VG%?GM1dwQ!TUF zFs5tQSunkpl7lgY+^R@Hh6)=2_h;1Cb-{+O5?2YF7D1&z06&0f?3C~sr0NiogN7#(p9c% z2}Fb6wlStA1dyf%S28?IFKhzgk~v&T#T6$y@ml2FT6SwQwk5yxXggD^{vfOGAlm#3 zH8&Wc2(P$*l4ER|#)C5{jaH6!wcfL>pi8SNTQ%9KNU&o~=h(xVNwyImES9HgHL^d( z`|>Mf`+ul9$KXtZu3N{M*tTuk#>BR5>q#=PZQHhO+qUgw&b;sWPSyGT-d(k-`bSsy zT6^#7PJ@KSl^AcXYtYidp0`o;8~F+PLmHeMfoYA(0>HVu;+8Df`AnG90C-nCM)1RQ zMcw1m6bxE%Hr~mscMegg9r9QmmxHsXH5JrHwP`ArYR`7JEaFU>I4-_6&e*=v8YC)% z9LQn$ZEM67N3N3!p&L*yUg8<&Sfw9WoRj=rD!kL7+oOw{X6;aASr=^RAZ$sHeWkIM zrN6rA0!Zk{ka$^hSPfQ6aGFmF&Zc@PMZ^osb9X6!TTe6n_K+U-FYwkFS20=|=nBJbfx`P1PJd;$B3 zN!hn*95GH+;@F?wa;~My%Nf)^TFeeRgkqQRwWl}e2wkehW*h-?AJLM`^Bf&n?={yX zqQ*NZ1XO$u>^;W%9Q=A8h%dq=T=>0<*thT9Fi6!pca~*gJ-DB-XRgDiY0tx~=89Q-G;} zLEAZ~BJ~n8$^Q6yjaawnxZReHEW4<)(jB;p$5XExOvqOU}WGjE!^;7erHEbp77Qvp*zDW8t)W-I8 ziS2m(+zRqzX~Q^DEeRP#_wB^?T%jvc+(6E|e7zpUzN{TnMb!QD9HM80BX@$XOR zU*G_Xy9a1fJCpw*k)+~YfUeAcX-8>pVjAZcN@8N7S`3t3 z=_E(f7f9{y#OHsVV5UOip3O;PnxBsx1xY%iA9KdESB{?!;P3NDd;Hx))@JP8kDt?w zP$kOUb)+-g?MkV;@4k+2S8kG$eYvXd0L{};{%dDyz(NrIequxVOtGF?*Wb_4T_I|T zU?upV1AG(mhq1NCT7iqIHJd>I_ZLMe;A^4v>u2-HSxMHjwB+xAEF8;*tP;!V_Y)sg zarzQE&JW8s!1==!!};pd*~sdJJT@OhX86sR}PF*ta;5GS!-`&K*vbvpt= zcf0N4J{~AO-jxK24x%Ar)}G<_H>=0(ckLOx!eEjjKvmv`Q_$T)d!V!aC*|g*FtT2} zV*C%7+NgptowHL8SQ{ZBa=xx19*9O9m){#-D2*j0j0&6SJvh>+NKwZczi<^Jkf4LT zHUt4;7(L>cKf>RyBjO?Y$M}tXo>X&>Q2${utG`NFv+T{q{I?V|Q#h>;f2JU=!0auB z&mS+c0KDc4Zd&zy&$P&|l_5x|(p)(Oh&k_?Y_QME7z3ky-XOy;LVcOl05A`zTZm+m zJNPrV0FFm5D38c2yo^{NhW+h4C$ODO7mmKkDiI34(`Ie%1x4(+tij?>=Etb$%D&>B zdo>LWR9c1h&b<#!0q|CLVI+xZ7QP`xsK*g-Kxhs(;nrzI`nt7Gv*d>7Ezyj0+P|0k z)5>Ph=8YG$W^uw+_IpO=}d`%t+Om2i}iV& zHDZWv&XWlm)SqEscN+D(bg6xwW8sd_gKha9gLmf|j%cyPvLuC&q#L8f&rve+f39%< zk*nD2{{1+tN^aT)-MJB)yqAv@2>a&|q3Df^d+;3OeK{>sOQ5iG=XIS9Sj3E* zu2F{6v8RgEEroAeQi33w3uXIU9MD#Q7SonSvnwmGbi5(&u)_*@BjCC62gA-6r% z8Yz*4Z5MN@cL*c9R8)G{9C0TAL^Z7dF|$TDVdaI2Y7KNp=M75o6l`Hwvb3&>ZV+1$ zcq4>21$pBLg~q!HdXg+?0aG(bq<@6N$q%0I!@(aT=k0=xIfUWVf!reGt2;V`_$|B^ zsPmB92+aQ7wd?0%%qz5*k$3o&0riSrEW#Q~`I^u5&u?Z#mhtr<2(jz~b_!g=PJoZ$ zSb4yOHMi)>yxm}cl_zBqDBPiFBAXFIf+uyI*1CwZjeBx#lDkOuSP;}(iBf1!iz&vJ zV%D;zc+C)YVb<_KmnUOnGts>b;!+nB2*Nd@qd-HxrP~XFe1DStbl}v9%q6*mh>3D{T%O{R~)1 z^{;s$;sOvKbA@ceV-7p>E$yUje^%@k=M>cZq!JPtd;fCN3O;R7F`MLFQEVcqZ@3m4 zv^^DQ+WPf^vs{kF-8{;d!E{>L4a+F=3xX`DG_8xB+^Cysuv>KEI3xp0P1u18yg_26=L2(0O~L?65X<@h{(jM8=|QP*)?o zoZ(wBFuKFNcWsZ79wqB*l=n+QJ4E=lLGx?nPEEeeB4 z3=--uDGgSR4OzcpDAESP1f(}Q&ZvbN!&g7#_34L1-r=#+4SCvVMGx~@LG2aA`Oykk zDMwSQmuwHS=YhU)jU=%1Kr5|gRQK5)EHg?)57Z7csiF=5?hejj)~|$onpMV#P9@{V zD|pK;-p8_AGTc8x^BTZ0;2Hcl+=L@jp6qDRD$3<#ftactxC{60#$g5ly10V*nhH3nasd&3sv*(R%4K*NJ(y_sK!sc}?AKKxwFo+qlNA zFb8|rLWhQ0TJvk=szB+9uG|~O)>&(4rAg%3!f@h%`wR8`V_GK;Po_pq&u{{8dn>4K zMCF)OL~M!VF}QDtQMHDH>JPwqHt5Gjnx8Y@gxCRlh*##EGU$>~j-G0^K;mz&*(?@0 z;pEJiX$m6ql@*TnBKIh7N0Qti_yvx46RY(Ziui()$V=4kN3#zc)HL3d^raFra)eYa zN3=_Tutl~q{$-jl#XxW4MB9?3WM|_V)uXp!vvPdP4FkfQ2^|vQ7f&swI&ZXvee!;P zh|-KT+wQ9#)X~6o%HjPhN=uN$8dseS8qbK>)}eCTWSLR%(>sFabP^ zi%x<+mXjCj5nxO#hbp6Nz^eifI&e@18s*wtw_-K-vQvKfb#!Nbd~mww=`M0aOdIc* zXaBT`N9X=&2ig78KKmza!4J_91PC2ta``8nN5i(*XbH2OJ62O1)E!s2ZfXbMVr@-< zHn7;-6*D2TIavu1*Op7Pw%M4fp^=lyZM8thD}!dYoYOJohbg?_uMb8_KkDJ(k`-tw zrog&q49{BH3(#EKe(&m(5$GY?yrke25t>r&;u;$%5%CoPzB_FXr-_(lGTwNKp6h=! zI}Db~>`}CgIRCFOJiBEbK)!yel%4I-vu#9s;Og{59BY)jWFqtK)`q3#5r5&P>S^Xn zPvt_ls9FxvqG99TLYI-w4PQaG>Kz@C9MVsH?v|1GD)YMPPlmfLUFd96xo61>n|UzZ zZnwAa6c`TuZ(Hbkzn0|7oh|0S_-%!L+bs%I8hIYtbh*CQX?H?^H+MxtT>g+IoIS_l^_6pMRZPVng%r{a!q-yf z?c5WA$zWB;m022L(aj->i9?Di-e1Z1@9DxZ)$$Q{MJq&#Psc3HuEly(0(9;>t9n!! zwJWnh4M?+9^q|zUa(zdPVGQ{AWTi5ZVAZc=W zel_T2&D70XWsZ=d5&ftQMC$QgC*$1NHT7MQ&`xVm%ud+x@J;YjwBWso| zntp=FQhLR>4&N|G{rRhP+FwYq*DFlhq2U3QB`S8@>$QLn0;B@g|KI^pfjRzLIAiAg zUqr`coK7dwcDh$}7Y`iRX^wT%WDxar_2Vm_%y!%|whTF+e%*slA5c=kz%0AyCY}zu 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

$H`n324Hryg9-TTRgSKv_xo`aN)NHEkV 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 Mfs#@}NfP1z0DimWUjP6A delta 207751 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 N+3cJE+*BlybEGf%!!2xR|8uC+O$w8&A&}2EtqI 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