model-checker 0.7.2__tar.gz

model_checker-0.7.2/LICENCE

@@ -0,0 +1,19 @@
+Copyright (c) 2024 Benjamin Brast-McKie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

model_checker-0.7.2/PKG-INFO

@@ -0,0 +1,204 @@
+Metadata-Version: 2.2
+Name: model-checker
+Version: 0.7.2
+Summary: A hyperintensional theorem prover for modal, counterfactual conditional, constitutive explanatory, and extensional operators.
+Author-email: Benjamin Brast-McKie <benbrastmckie@gmail.com>, Miguel Buitrago <mbuit82@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/benbrastmckie/ModelChecker
+Project-URL: Issues, https://github.com/benbrastmckie/ModelChecker/issues
+Keywords: semantics,Z3,logic,counterfactuals,modality,model checker,theorem prover,hyperintensionality
+Classifier: Programming Language :: Python :: 3.8
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: z3-solver
+
+This package draws on the SMT solver [Z3](https://github.com/Z3Prover/z3) to provide a [programmatic semantics]() for a number of hyperintensional operators along with a general purpose methodology for developing novel programmatic semantic theories and studying their resulting logics.
+Rather than computing whether a given sentence is a logical consequence of some set of sentences by hand, these resources allow users to find countermodels or establish logical consequence up to a finite level complexity specified by the user.
+Instead of only developing a model-theoretic version of a semantics and working out the consequence with pen and paper, this project provides tooling for finding hyperintensional countermodels and establish validity over models up to a user specified level of complexity in a propositional language with the following operators:
+
+  - `neg` for _negation_
+  - `wedge` for _conjunction_
+  - `vee` for _disjunction_
+  - `rightarrow` for the _material conditional_
+  - `leftrightarrow` for the _material biconditional_
+  - `boxright` for the _must counterfactual conditional_
+  - `circleright` for the _might counterfactual conditional_
+  - `Box` for _necessity_
+  - `Diamond` for _possibility_
+  - `leq` for _ground_ read 'sufficient for'
+  - `sqsubseteq` for _essence_ read 'necessary for'
+  - `equiv` for _propositional identity_ read 'just is for'
+  - `preceq` for _relevance_
+
+### Screenshot
+
+> NOTE: Additional images can be found [here](https://github.com/benbrastmckie/ModelChecker/blob/master/Images/screenshots.md).
+
+## Programmatic Semantics
+
+A programmatic methodology in semantics streamlines the otherwise computationally grueling process of developing and testing novel semantic theories and exploring their logics.
+Although computational systems cannot search the space of all models (typically a proper class), the absence of bitvector countermodels up to a finite level of complexity provides evidence for logical consequence, where the strength of this evidence increases with the range of distinct models surveyed.
+If finite countermodels exist, users will be able to generate and print those models rather than attempting to do so by hand.
+
+The [hyperintensional semantics](#Hyperintensional-Semantics) for the operators indicated above is briefly discussed below.
+In addition to including semantic clauses for the operators indicated above, this project provides templates and flexible tooling that can be adapted to accommodate new operators.
+By easing the process of investigating increasingly complex semantic theories, this methodology aims to support the growth and maturity of semantics as a discipline.
+
+Although computational resources are common place, the ability to make use of these resources to develop and explore the implications of novel semantic theories remains limited.
+For instance, [Prover9 and Mace](https://www.cs.unm.edu/~mccune/prover9/) are restricted to first-order and equational statements.
+However, for the purposes of semantics, it is desirable to: (1) introduce a range of primitive operators; (2) specify novel semantic clauses for those operators; (3) define frame constraints and a space of models for the resulting language; (4) test which sentences are a logical consequence of which; and (5) print readable countermodels if there are any.
+Rather than displacing model theory and proof theory, developing and testing a programmatic semantics for a language aims to support the study of extensionally adequate logics before attempting to establish completeness.
+
+## Installation
+
+```
+pip install model-checker
+```
+
+The project has the `z3-solver` as a dependency and will be installed automatically.
+More information can be found in the accessible installation [instructions](https://github.com/benbrastmckie/ModelChecker/blob/master/installation.md).
+
+## Updating
+
+Once installed, you can check the current version of the `model-checker` with:
+
+```
+model-checker -v
+```
+
+To update to the latest version, run:
+
+```
+model-checker -u
+```
+
+## Usage
+
+Run `model-checker` in the terminal without arguments to create a new project with the following modules:
+
+  - `semantic.py` specifies the Z3 primitives, frame constraints, models, theory of logical consequence, defined semantic terms, theory of propositions, and instructions for displaying countermodels.
+  - `operators.py` specifies the semantic clauses for the primitive operators included in the default language along with a number of defined operators.
+  - `examples.py` specifies the settings, a number of examples, and the protocol for finding and printing countermodels if there are any.
+
+After changing to the project directory that you created, run `model-checker project_examples.py` to find a countermodel if there is any.
+The example settings specify the following inputs where the defaults are indicated below:
+
+  - The number of atomic states to include in each model: `N = 3`.
+  - An option to require all sentence letters to be contingent: `contingent = False`.
+  - An option to require all sentence letters to have at least one verifier and at least one falsifier: `non_empty = False`.
+  - An option to prevent sentence letters from having the null state as a verifier or a falsifier: `non_null = False`.
+  - An option to prevent sentence letters from having overlapping verifiers or falsifiers: `disjoint = False`.
+  - The maximum time in seconds to spend looking for a model: `max_time = 1`.
+  <!-- - Find a model with the smallest number of atomic elements: `optimize_bool = False`. -->
+
+A number of general settings may also be specified with the following:
+
+  - An option to print impossible states: `print_impssible = False`.
+  - An option to print all Z3 constraints or unsatisfiable core constraints: `print_constraints = False`.
+  - An option to prompt the user to append the output to the current file or to create a new file: `save_output = False`.
+
+Examples are specified by defining a list as follows:
+  ```
+  # CF_CM_1: COUNTERFACTUAL ANTECEDENT STRENGTHENING
+
+  CF_CM_1_premises = ['(A \\boxright C)']
+  CF_CM_1_conclusions = ['((A \\wedge B) \\boxright C)']
+  CF_CM_1_settings = {
+      'N' : 3,
+      'contingent' : True,
+      'non_null' : True,
+      'non_empty' : True,
+      'disjoint' : False,
+      'max_time' : 1,
+  }
+
+  CF_CM_1_example = [
+      CF_CM_1_premises,
+      CF_CM_1_conclusions,
+      CF_CM_1_settings,
+  ]
+  ```
+The example `CF_CM_1_example` includes:
+
+  - A list of zero or more premises that are treated conjunctively: `premises = []`.
+  - A list of zero or more conclusions that are treated disjunctively: `conclusions = []`.
+  - A dictionary of settings where the defaults are indicated above.
+
+Alternatively, users can define a general stock of `example_settings`, reusing these for an number of examples.
+Users can override these settings from the command line by including the following flags:
+
+  - Include `-c` to set `contingent = True`.
+  - Include `-e` to set `non_empty = True`.
+  - Include `-n` to set `non_null = True`.
+  - Include `-d` to set `disjoint = True`.
+  - Include `-i` to set `print_impossibe = True`.
+  - Include `-p` to set `print_constraints = True`.
+  - Include `-s` to set `save_bool = True`.
+
+Additional flags have been included in order to manage the package version:
+
+  - Include `-h` to print help information about the package and its usage.
+  - Include `-v` to print the installed version number.
+  - Include `-u` to upgrade to the latest version.
+
+## Hyperintensional Semantics
+
+This section sketches the underlying semantics.
+More information can be found in the GitHub [repository](https://github.com/benbrastmckie/ModelChecker). 
+
+The semantics is hyperintensional insofar as sentences are evaluated at _states_ which may be partial rather than total as in intensional semantic theories.
+States are modeled by bitvectors of a specified length (e.g., `#b00101` has length `5`), where _state fusion_ is modeled by the bitwise OR operator `|`.
+For instance, `#b00101 | #b11001 = #b11101`.
+The _atomic states_ have exactly one occurrence of `1` and the _null state_ has no occurrences of `1`.
+The space of states is finite and closed under fusion.
+
+States are named by lowercase letters in order to print readable countermodels.
+Fusions are printed using `.` where `a.b` is the fusion of the states `a` and `b`.
+A state `a` is _part_ of a state `b` just in case `a.b = b`.
+States may be either _possible_ or _impossible_ where the null state is required to be possible and every part of a possible state is possible.
+The states `a` and `b` are _compatible_ just in case `a.b` is possible.
+A _world state_ is any state that is both possible and includes every compatible state as a part.
+
+Sentences are assigned _verifier states_ and _falsifier states_ where both the verifiers and falsifiers are required to be closed under fusion.
+A sentence is _true at_ a world state `w` just in case `w` includes a verifier for that sentence as a part and _false at_ `w` just in case `w` includes a falsifier for that sentence as a part.
+In order to ensure that sentence letters have at most one truth-value at each world state, a fusion `a.b` is required to be impossible whenever `a` is verifier for a sentence letter `A` and `b` is a falsifier for `A`.
+Additionally, sentence letters are guaranteed to have at least one truth-value at each world state by requiring every possible state to be compatible with either a verifier or falsifier for any sentence letter.
+
+A _negated sentence_ is verified by the falsifiers for the sentence negated and falsified by the verifiers for the sentence negated.
+A _conjunctive sentence_ is verified by the pairwise fusions of verifiers for the conjuncts and falsified by falsifiers for either of the conjuncts or fusions thereof.
+A _disjunctive sentence_ is verified by the verifiers for either disjunct or fusions thereof and falsified by pairwise fusions of falsifiers for the disjuncts.
+Conjunction and disjunction are dual operators obeying the standard idempotence and De Morgan laws.
+The absorption laws do not hold, nor does conjunction distribute over disjunction, nor _vice versa_.
+For a defense of the background theory of hyperintensional propositions, see this [paper](https://link.springer.com/article/10.1007/s10992-021-09612-w).
+
+<!-- By contrast with the _bilateral_ extensional operators which treat both verifiers and falsifiers, the semantics for `not` is _unilateral_. -->
+<!-- In particular `not A` is verified by a state `s` just in case every non-null part of `s` is incompatible with a verifier for `A` and every verifier for `A` is incompatible with some non-null part of `s`. -->
+<!-- This semantics is further motivated and elaborated in [Bernard and Champollion](https://ling.auf.net/lingbuzz/007730/current.html) and included here for comparison. -->
+
+A _necessity sentence_ `Box A` is true at a world just in case every world state includes a part that verifies `A` and a _possibility sentence_ `Diamond A` is true at a world just in case some world state includes a part that verifies `A`.
+Given a world state `w` and state `s`, an `s`_-alternative_ to `w` is any world state to include as parts both `s` and a maximal part of `w` that is compatible with `s`.
+A _must counterfactual conditional sentences_ `A boxright B` is true at a world state `w` just in case its consequent is true at any `s`-alternative to `w` for any verifier `s` for the antecedent of the counterfactual.
+A _might counterfactual conditional sentences_ `A boxright B` is true at a world state `w` just in case its consequent is true at some `s`-alternative to `w` for some verifier `s` for the antecedent of the counterfactual.
+The semantic theory for counterfactual conditionals is motivated and further elaborated in this accompanying [paper](https://github.com/benbrastmckie/ModelChecker/blob/master/Counterfactuals.pdf).
+This account builds on [Fine 2012](https://www.pdcnet.org/jphil/content/jphil_2012_0109_0003_0221_0246) and [Fine2012a](https://link.springer.com/article/10.1007/s11229-012-0094-y?error=cookies_not_supported&code=5166a4da-1834-438c-9f93-75b61f58b6db).
+
+A _grounding sentence_ `A leq B` may be read '`A` is _sufficient for_ `B`' and an _essence sentence_ `A sqsubseteq B` may be read '`A` is _necessary for_ `B`'.
+A _propositional identity sentence_ `A equiv B` may be read '`A` _just is for_ `B`'.
+A _relevance sentence_ `A preceq B` may be read '`A` _is wholly relevant to_ `B`'.
+The semantics for ground requires every verifier for the antecedent to be a verifier for the consequent, any fusion of a falsifier for the antecedent and consequent to be a falsifier for the consequent, and any falsifier for the consequent to have a part that falsifies the antecedent.
+The semantics for essence requires every fusion of a verifier for the antecedent and consequent to be a verifier for the consequent, any verifier for the consequent must have a part that verifies the antecedent, and every falsifier for the antecedent to be a falsifier for the consequent.
+The semantics for propositional identity requires the two arguments to have the same verifiers and falsifiers.
+The semantics for relevance requires any fusion of verifiers for the antecedent and consequent to be a verifier for the consequent and, similarly, any fusion of falsifiers for the antecedent and consequent to be a falsifier for the consequent.
+Whereas the first three constitutive operators are interdefinable, relevance is definable in terms of the other constitutive operators but not _vice versa_:
+
+- `A leq B  :=  neg A sqsubseteq neg B  :=  (A vee B) equiv B`.
+- `A sqsubseteq B  :=  neg A leq neg B  :=  (A wedge B) equiv B`.
+- `A equiv B  :=  (A leq B) wedge (B leq A)  :=  (A sqsubseteq B) wedge (B sqsubseteq A)`.
+- `A preceq B  :=  (A wedge B) leq B :=  (A vee B) sqsubseteq B`.
+
+Instead of a Boolean lattice as in extensional and intensional semantics theories, the space of hyperintensional propositions forms a non-interlaced bilattice as described in this [paper](https://link.springer.com/article/10.1007/s10992-021-09612-w), building on [Fine 2017](https://link.springer.com/article/10.1007/s10992-016-9413-y).
+
+More information can be found in the GitHub [repository](https://github.com/benbrastmckie/ModelChecker) as well as in this recent [manuscript](https://github.com/benbrastmckie/ModelChecker/blob/master/Counterfactuals.pdf). 
+

model_checker-0.7.2/README.md

@@ -0,0 +1,188 @@
+This package draws on the SMT solver [Z3](https://github.com/Z3Prover/z3) to provide a [programmatic semantics]() for a number of hyperintensional operators along with a general purpose methodology for developing novel programmatic semantic theories and studying their resulting logics.
+Rather than computing whether a given sentence is a logical consequence of some set of sentences by hand, these resources allow users to find countermodels or establish logical consequence up to a finite level complexity specified by the user.
+Instead of only developing a model-theoretic version of a semantics and working out the consequence with pen and paper, this project provides tooling for finding hyperintensional countermodels and establish validity over models up to a user specified level of complexity in a propositional language with the following operators:
+
+  - `neg` for _negation_
+  - `wedge` for _conjunction_
+  - `vee` for _disjunction_
+  - `rightarrow` for the _material conditional_
+  - `leftrightarrow` for the _material biconditional_
+  - `boxright` for the _must counterfactual conditional_
+  - `circleright` for the _might counterfactual conditional_
+  - `Box` for _necessity_
+  - `Diamond` for _possibility_
+  - `leq` for _ground_ read 'sufficient for'
+  - `sqsubseteq` for _essence_ read 'necessary for'
+  - `equiv` for _propositional identity_ read 'just is for'
+  - `preceq` for _relevance_
+
+### Screenshot
+
+> NOTE: Additional images can be found [here](https://github.com/benbrastmckie/ModelChecker/blob/master/Images/screenshots.md).
+
+## Programmatic Semantics
+
+A programmatic methodology in semantics streamlines the otherwise computationally grueling process of developing and testing novel semantic theories and exploring their logics.
+Although computational systems cannot search the space of all models (typically a proper class), the absence of bitvector countermodels up to a finite level of complexity provides evidence for logical consequence, where the strength of this evidence increases with the range of distinct models surveyed.
+If finite countermodels exist, users will be able to generate and print those models rather than attempting to do so by hand.
+
+The [hyperintensional semantics](#Hyperintensional-Semantics) for the operators indicated above is briefly discussed below.
+In addition to including semantic clauses for the operators indicated above, this project provides templates and flexible tooling that can be adapted to accommodate new operators.
+By easing the process of investigating increasingly complex semantic theories, this methodology aims to support the growth and maturity of semantics as a discipline.
+
+Although computational resources are common place, the ability to make use of these resources to develop and explore the implications of novel semantic theories remains limited.
+For instance, [Prover9 and Mace](https://www.cs.unm.edu/~mccune/prover9/) are restricted to first-order and equational statements.
+However, for the purposes of semantics, it is desirable to: (1) introduce a range of primitive operators; (2) specify novel semantic clauses for those operators; (3) define frame constraints and a space of models for the resulting language; (4) test which sentences are a logical consequence of which; and (5) print readable countermodels if there are any.
+Rather than displacing model theory and proof theory, developing and testing a programmatic semantics for a language aims to support the study of extensionally adequate logics before attempting to establish completeness.
+
+## Installation
+
+```
+pip install model-checker
+```
+
+The project has the `z3-solver` as a dependency and will be installed automatically.
+More information can be found in the accessible installation [instructions](https://github.com/benbrastmckie/ModelChecker/blob/master/installation.md).
+
+## Updating
+
+Once installed, you can check the current version of the `model-checker` with:
+
+```
+model-checker -v
+```
+
+To update to the latest version, run:
+
+```
+model-checker -u
+```
+
+## Usage
+
+Run `model-checker` in the terminal without arguments to create a new project with the following modules:
+
+  - `semantic.py` specifies the Z3 primitives, frame constraints, models, theory of logical consequence, defined semantic terms, theory of propositions, and instructions for displaying countermodels.
+  - `operators.py` specifies the semantic clauses for the primitive operators included in the default language along with a number of defined operators.
+  - `examples.py` specifies the settings, a number of examples, and the protocol for finding and printing countermodels if there are any.
+
+After changing to the project directory that you created, run `model-checker project_examples.py` to find a countermodel if there is any.
+The example settings specify the following inputs where the defaults are indicated below:
+
+  - The number of atomic states to include in each model: `N = 3`.
+  - An option to require all sentence letters to be contingent: `contingent = False`.
+  - An option to require all sentence letters to have at least one verifier and at least one falsifier: `non_empty = False`.
+  - An option to prevent sentence letters from having the null state as a verifier or a falsifier: `non_null = False`.
+  - An option to prevent sentence letters from having overlapping verifiers or falsifiers: `disjoint = False`.
+  - The maximum time in seconds to spend looking for a model: `max_time = 1`.
+  <!-- - Find a model with the smallest number of atomic elements: `optimize_bool = False`. -->
+
+A number of general settings may also be specified with the following:
+
+  - An option to print impossible states: `print_impssible = False`.
+  - An option to print all Z3 constraints or unsatisfiable core constraints: `print_constraints = False`.
+  - An option to prompt the user to append the output to the current file or to create a new file: `save_output = False`.
+
+Examples are specified by defining a list as follows:
+  ```
+  # CF_CM_1: COUNTERFACTUAL ANTECEDENT STRENGTHENING
+
+  CF_CM_1_premises = ['(A \\boxright C)']
+  CF_CM_1_conclusions = ['((A \\wedge B) \\boxright C)']
+  CF_CM_1_settings = {
+      'N' : 3,
+      'contingent' : True,
+      'non_null' : True,
+      'non_empty' : True,
+      'disjoint' : False,
+      'max_time' : 1,
+  }
+
+  CF_CM_1_example = [
+      CF_CM_1_premises,
+      CF_CM_1_conclusions,
+      CF_CM_1_settings,
+  ]
+  ```
+The example `CF_CM_1_example` includes:
+
+  - A list of zero or more premises that are treated conjunctively: `premises = []`.
+  - A list of zero or more conclusions that are treated disjunctively: `conclusions = []`.
+  - A dictionary of settings where the defaults are indicated above.
+
+Alternatively, users can define a general stock of `example_settings`, reusing these for an number of examples.
+Users can override these settings from the command line by including the following flags:
+
+  - Include `-c` to set `contingent = True`.
+  - Include `-e` to set `non_empty = True`.
+  - Include `-n` to set `non_null = True`.
+  - Include `-d` to set `disjoint = True`.
+  - Include `-i` to set `print_impossibe = True`.
+  - Include `-p` to set `print_constraints = True`.
+  - Include `-s` to set `save_bool = True`.
+
+Additional flags have been included in order to manage the package version:
+
+  - Include `-h` to print help information about the package and its usage.
+  - Include `-v` to print the installed version number.
+  - Include `-u` to upgrade to the latest version.
+
+## Hyperintensional Semantics
+
+This section sketches the underlying semantics.
+More information can be found in the GitHub [repository](https://github.com/benbrastmckie/ModelChecker). 
+
+The semantics is hyperintensional insofar as sentences are evaluated at _states_ which may be partial rather than total as in intensional semantic theories.
+States are modeled by bitvectors of a specified length (e.g., `#b00101` has length `5`), where _state fusion_ is modeled by the bitwise OR operator `|`.
+For instance, `#b00101 | #b11001 = #b11101`.
+The _atomic states_ have exactly one occurrence of `1` and the _null state_ has no occurrences of `1`.
+The space of states is finite and closed under fusion.
+
+States are named by lowercase letters in order to print readable countermodels.
+Fusions are printed using `.` where `a.b` is the fusion of the states `a` and `b`.
+A state `a` is _part_ of a state `b` just in case `a.b = b`.
+States may be either _possible_ or _impossible_ where the null state is required to be possible and every part of a possible state is possible.
+The states `a` and `b` are _compatible_ just in case `a.b` is possible.
+A _world state_ is any state that is both possible and includes every compatible state as a part.
+
+Sentences are assigned _verifier states_ and _falsifier states_ where both the verifiers and falsifiers are required to be closed under fusion.
+A sentence is _true at_ a world state `w` just in case `w` includes a verifier for that sentence as a part and _false at_ `w` just in case `w` includes a falsifier for that sentence as a part.
+In order to ensure that sentence letters have at most one truth-value at each world state, a fusion `a.b` is required to be impossible whenever `a` is verifier for a sentence letter `A` and `b` is a falsifier for `A`.
+Additionally, sentence letters are guaranteed to have at least one truth-value at each world state by requiring every possible state to be compatible with either a verifier or falsifier for any sentence letter.
+
+A _negated sentence_ is verified by the falsifiers for the sentence negated and falsified by the verifiers for the sentence negated.
+A _conjunctive sentence_ is verified by the pairwise fusions of verifiers for the conjuncts and falsified by falsifiers for either of the conjuncts or fusions thereof.
+A _disjunctive sentence_ is verified by the verifiers for either disjunct or fusions thereof and falsified by pairwise fusions of falsifiers for the disjuncts.
+Conjunction and disjunction are dual operators obeying the standard idempotence and De Morgan laws.
+The absorption laws do not hold, nor does conjunction distribute over disjunction, nor _vice versa_.
+For a defense of the background theory of hyperintensional propositions, see this [paper](https://link.springer.com/article/10.1007/s10992-021-09612-w).
+
+<!-- By contrast with the _bilateral_ extensional operators which treat both verifiers and falsifiers, the semantics for `not` is _unilateral_. -->
+<!-- In particular `not A` is verified by a state `s` just in case every non-null part of `s` is incompatible with a verifier for `A` and every verifier for `A` is incompatible with some non-null part of `s`. -->
+<!-- This semantics is further motivated and elaborated in [Bernard and Champollion](https://ling.auf.net/lingbuzz/007730/current.html) and included here for comparison. -->
+
+A _necessity sentence_ `Box A` is true at a world just in case every world state includes a part that verifies `A` and a _possibility sentence_ `Diamond A` is true at a world just in case some world state includes a part that verifies `A`.
+Given a world state `w` and state `s`, an `s`_-alternative_ to `w` is any world state to include as parts both `s` and a maximal part of `w` that is compatible with `s`.
+A _must counterfactual conditional sentences_ `A boxright B` is true at a world state `w` just in case its consequent is true at any `s`-alternative to `w` for any verifier `s` for the antecedent of the counterfactual.
+A _might counterfactual conditional sentences_ `A boxright B` is true at a world state `w` just in case its consequent is true at some `s`-alternative to `w` for some verifier `s` for the antecedent of the counterfactual.
+The semantic theory for counterfactual conditionals is motivated and further elaborated in this accompanying [paper](https://github.com/benbrastmckie/ModelChecker/blob/master/Counterfactuals.pdf).
+This account builds on [Fine 2012](https://www.pdcnet.org/jphil/content/jphil_2012_0109_0003_0221_0246) and [Fine2012a](https://link.springer.com/article/10.1007/s11229-012-0094-y?error=cookies_not_supported&code=5166a4da-1834-438c-9f93-75b61f58b6db).
+
+A _grounding sentence_ `A leq B` may be read '`A` is _sufficient for_ `B`' and an _essence sentence_ `A sqsubseteq B` may be read '`A` is _necessary for_ `B`'.
+A _propositional identity sentence_ `A equiv B` may be read '`A` _just is for_ `B`'.
+A _relevance sentence_ `A preceq B` may be read '`A` _is wholly relevant to_ `B`'.
+The semantics for ground requires every verifier for the antecedent to be a verifier for the consequent, any fusion of a falsifier for the antecedent and consequent to be a falsifier for the consequent, and any falsifier for the consequent to have a part that falsifies the antecedent.
+The semantics for essence requires every fusion of a verifier for the antecedent and consequent to be a verifier for the consequent, any verifier for the consequent must have a part that verifies the antecedent, and every falsifier for the antecedent to be a falsifier for the consequent.
+The semantics for propositional identity requires the two arguments to have the same verifiers and falsifiers.
+The semantics for relevance requires any fusion of verifiers for the antecedent and consequent to be a verifier for the consequent and, similarly, any fusion of falsifiers for the antecedent and consequent to be a falsifier for the consequent.
+Whereas the first three constitutive operators are interdefinable, relevance is definable in terms of the other constitutive operators but not _vice versa_:
+
+- `A leq B  :=  neg A sqsubseteq neg B  :=  (A vee B) equiv B`.
+- `A sqsubseteq B  :=  neg A leq neg B  :=  (A wedge B) equiv B`.
+- `A equiv B  :=  (A leq B) wedge (B leq A)  :=  (A sqsubseteq B) wedge (B sqsubseteq A)`.
+- `A preceq B  :=  (A wedge B) leq B :=  (A vee B) sqsubseteq B`.
+
+Instead of a Boolean lattice as in extensional and intensional semantics theories, the space of hyperintensional propositions forms a non-interlaced bilattice as described in this [paper](https://link.springer.com/article/10.1007/s10992-021-09612-w), building on [Fine 2017](https://link.springer.com/article/10.1007/s10992-016-9413-y).
+
+More information can be found in the GitHub [repository](https://github.com/benbrastmckie/ModelChecker) as well as in this recent [manuscript](https://github.com/benbrastmckie/ModelChecker/blob/master/Counterfactuals.pdf). 
+

model_checker-0.7.2/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "model-checker"
+version = "0.7.2"
+description = "A hyperintensional theorem prover for modal, counterfactual conditional, constitutive explanatory, and extensional operators."
+authors = [
+    { name = "Benjamin Brast-McKie", email = "benbrastmckie@gmail.com" },
+    { name = "Miguel Buitrago", email = "mbuit82@gmail.com" },
+]
+license = { text = "MIT" }
+readme = "README.md"
+classifiers = [
+    "Programming Language :: Python :: 3.8",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+keywords = ["semantics", "Z3", "logic", "counterfactuals", "modality", "model checker", "theorem prover", "hyperintensionality"]
+dependencies = [
+    "z3-solver",
+]
+
+[project.urls]
+Homepage = "https://github.com/benbrastmckie/ModelChecker"
+Issues = "https://github.com/benbrastmckie/ModelChecker/issues"
+
+[project.scripts]
+model-checker = "model_checker.__main__:main"

model_checker-0.7.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

model_checker-0.7.2/src/model_checker/__init__.py

@@ -0,0 +1,78 @@
+# __init__.py
+from importlib.metadata import version
+try:
+    __version__ = version("model-checker")
+except ImportError:
+    __version__ = "unknown"
+
+# Import specific items from utils
+from .utils import (
+    ForAll,
+    Exists,
+    bitvec_to_substates,
+)
+
+# Import model as a whole
+from . import model
+
+# Import syntactic as a whole
+from . import syntactic
+
+# Import specific items from utils
+from .builder import (
+    make_model_for,
+    find_max_N,
+    translate,
+    # run_comparison, # update
+    # save_comparisons, # update
+)
+
+# Import specific items from semantic
+from .semantic import (
+    Semantics,
+    ImpositionSemantics,
+    Proposition,
+)
+
+# Import specific items from primitive
+from .primitive import (
+    AndOperator, NegationOperator, OrOperator,            # extensional
+    TopOperator, BotOperator,                             # top and bottom
+    IdentityOperator, GroundOperator, EssenceOperator,    # constitutive
+    RelevanceOperator,                                    # relevance
+    NecessityOperator, PossibilityOperator,               # modal
+    CounterfactualOperator, ImpositionOperator,           # counterfactual
+)
+
+from .defined import (
+    ConditionalOperator, BiconditionalOperator,           # extensional
+    DefEssenceOperator, DefGroundOperator,                # constitutive
+    MightCounterfactualOperator, MightImpositionOperator, # counterfactual
+    
+)
+
+
+# Import specific items from __main__
+from .__main__ import (
+    BuildModule,
+    BuildExample,
+    main,
+)
+
+# Define the public API of the package
+__all__ = [
+    "model", "syntactic",
+    "ForAll", "Exists", "bitvec_to_substates",
+    "make_model_for", "find_max_N", "translate", #"run_comparison", "save_comparisons",
+    "Semantics", "ImpositionSemantics", "Proposition",
+    "ConditionalOperator", "BiconditionalOperator",
+    "DefEssenceOperator", "DefGroundOperator",
+    "MightCounterfactualOperator", "MightImpositionOperator",
+    "AndOperator", "NegationOperator", "OrOperator",
+    "TopOperator", "BotOperator",
+    "IdentityOperator", "GroundOperator", "EssenceOperator",
+    "RelevanceOperator",
+    "NecessityOperator", "PossibilityOperator",
+    "CounterfactualOperator", "ImpositionOperator",
+    "BuildModule", "BuildExample", "main",
+]