occam-verify-cli 0.0.894 → 0.0.896
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/conclusion.js +37 -14
- package/lib/metaConsequent.js +29 -10
- package/lib/metaSupposition.js +44 -23
- package/lib/premise.js +82 -53
- package/lib/verifier/nodes/intrinsicLevelAgainstMetaLevel.js +2 -40
- package/package.json +1 -1
- package/src/conclusion.js +54 -26
- package/src/metaConsequent.js +40 -17
- package/src/metaSupposition.js +69 -44
- package/src/premise.js +143 -109
- package/src/verifier/nodes/intrinsicLevelAgainstMetaLevel.js +0 -61
package/src/conclusion.js
CHANGED
|
@@ -5,71 +5,99 @@ import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
|
|
|
5
5
|
import intrinsicLevelAgainstMetaLevelNodesVerifier from "./verifier/nodes/intrinsicLevelAgainstMetaLevel";
|
|
6
6
|
|
|
7
7
|
import { nodeAsString } from "./utilities/string";
|
|
8
|
-
import { metastatementNodeFromMetastatementString } from "./utilities/node";
|
|
8
|
+
import { statementNodeFromStatementString, metastatementNodeFromMetastatementString } from "./utilities/node";
|
|
9
9
|
|
|
10
10
|
export default class Conclusion {
|
|
11
|
-
constructor(metastatementNode) {
|
|
11
|
+
constructor(metastatementNode, statementNode) {
|
|
12
12
|
this.metastatementNode = metastatementNode;
|
|
13
|
+
this.statementNode = statementNode;
|
|
13
14
|
}
|
|
14
15
|
|
|
15
16
|
getMetastatementNode() {
|
|
16
17
|
return this.metastatementNode;
|
|
17
18
|
}
|
|
18
19
|
|
|
20
|
+
getStatementNode() {
|
|
21
|
+
return this.statementNode;
|
|
22
|
+
}
|
|
23
|
+
|
|
19
24
|
matchStatementNode(statementNode, substitutions, localContext, statementLocalContext) {
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
25
|
+
let statementNodeMatches = false;
|
|
26
|
+
|
|
27
|
+
if (this.metastatementNode !== null) {
|
|
28
|
+
const nonTerminalNodeA = this.metastatementNode, ///
|
|
29
|
+
nonTerminalNodeB = statementNode, ///
|
|
30
|
+
localContextA = localContext, ///
|
|
31
|
+
localContextB = statementLocalContext, ///
|
|
32
|
+
nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
|
|
33
|
+
const verifyAhead = true;
|
|
26
34
|
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
35
|
+
return verifyAhead;
|
|
36
|
+
});
|
|
37
|
+
|
|
38
|
+
statementNodeMatches = nonTerminalNodeVerified; ///
|
|
39
|
+
}
|
|
30
40
|
|
|
31
41
|
return statementNodeMatches;
|
|
32
42
|
}
|
|
33
43
|
|
|
34
44
|
matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
45
|
+
let metastatementNodeMatches = false;
|
|
46
|
+
|
|
47
|
+
if (this.metastatementNode !== null) {
|
|
48
|
+
const nonTerminalNodeA = this.metastatementNode, ///
|
|
49
|
+
nonTerminalNodeB = metastatementNode, ///
|
|
50
|
+
fileContextA = fileContext, ///
|
|
51
|
+
localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
|
|
52
|
+
localMetaContextB = localMetaContext, ///
|
|
53
|
+
nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
|
|
54
|
+
const verifiedAhead = true;
|
|
55
|
+
|
|
56
|
+
return verifiedAhead;
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
metastatementNodeMatches = nonTerminalNodeVerified; ///
|
|
60
|
+
}
|
|
46
61
|
|
|
47
62
|
return metastatementNodeMatches;
|
|
48
63
|
}
|
|
49
64
|
|
|
50
65
|
toJSON(tokens) {
|
|
51
66
|
const metastatementString = nodeAsString(this.metastatementNode, tokens),
|
|
67
|
+
statementString = nodeAsString(this.statementNode, tokens),
|
|
52
68
|
metastatement = metastatementString, ///
|
|
69
|
+
statement = statementString, ///
|
|
53
70
|
json = {
|
|
54
|
-
metastatement
|
|
71
|
+
metastatement,
|
|
72
|
+
statement
|
|
55
73
|
};
|
|
56
74
|
|
|
57
75
|
return json;
|
|
58
76
|
}
|
|
59
77
|
|
|
60
78
|
static fromMetastatementNode(metastatementNode) {
|
|
61
|
-
const
|
|
79
|
+
const statementNode = null,
|
|
80
|
+
conclusion = new Conclusion(metastatementNode, statementNode);
|
|
81
|
+
|
|
82
|
+
return conclusion;
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
static fromStatementNode(statementNode) {
|
|
86
|
+
const metastatementNode = null,
|
|
87
|
+
conclusion = new Conclusion(metastatementNode, statementNode);
|
|
62
88
|
|
|
63
89
|
return conclusion;
|
|
64
90
|
}
|
|
65
91
|
|
|
66
92
|
static fromJSONAndFileContext(json, fileContext) {
|
|
67
|
-
const { metastatement } = json,
|
|
93
|
+
const { metastatement, statement } = json,
|
|
68
94
|
metastatementString = metastatement, ///
|
|
95
|
+
statementString = statement, ///
|
|
69
96
|
lexer = fileContext.getLexer(),
|
|
70
97
|
parser = fileContext.getParser(),
|
|
71
98
|
metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
|
|
72
|
-
|
|
99
|
+
statementNode = statementNodeFromStatementString(statementString, lexer, parser),
|
|
100
|
+
conclusion = new Conclusion(metastatementNode, statementNode);
|
|
73
101
|
|
|
74
102
|
return conclusion;
|
|
75
103
|
}
|
package/src/metaConsequent.js
CHANGED
|
@@ -4,56 +4,79 @@ import LocalMetaContext from "./context/localMeta";
|
|
|
4
4
|
import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
|
|
5
5
|
|
|
6
6
|
import { nodeAsString } from "./utilities/string";
|
|
7
|
-
import { metastatementNodeFromMetastatementString } from "./utilities/node";
|
|
7
|
+
import { statementNodeFromStatementString, metastatementNodeFromMetastatementString } from "./utilities/node";
|
|
8
8
|
|
|
9
9
|
export default class MetaConsequent {
|
|
10
|
-
constructor(metastatementNode) {
|
|
10
|
+
constructor(metastatementNode, statementNode) {
|
|
11
11
|
this.metastatementNode = metastatementNode;
|
|
12
|
+
this.statementNode = statementNode;
|
|
12
13
|
}
|
|
13
14
|
|
|
14
15
|
getMetastatementNode() {
|
|
15
16
|
return this.metastatementNode;
|
|
16
17
|
}
|
|
17
18
|
|
|
19
|
+
getStatementNode() {
|
|
20
|
+
return this.statementNode;
|
|
21
|
+
}
|
|
22
|
+
|
|
18
23
|
matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
24
|
+
let metastatementNodeMatches = false;
|
|
25
|
+
|
|
26
|
+
if (this.metastatementNode !== null) {
|
|
27
|
+
const nonTerminalNodeA = this.metastatementNode, ///
|
|
28
|
+
nonTerminalNodeB = metastatementNode, ///
|
|
29
|
+
fileContextA = fileContext, ///
|
|
30
|
+
localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
|
|
31
|
+
localMetaContextB = localMetaContext, ///
|
|
32
|
+
nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
|
|
33
|
+
const verifiedAhead = true;
|
|
34
|
+
|
|
35
|
+
return verifiedAhead;
|
|
36
|
+
});
|
|
37
|
+
|
|
38
|
+
metastatementNodeMatches = nonTerminalNodeVerified; ///
|
|
39
|
+
}
|
|
30
40
|
|
|
31
41
|
return metastatementNodeMatches;
|
|
32
42
|
}
|
|
33
43
|
|
|
34
44
|
toJSON(tokens) {
|
|
35
45
|
const metastatementString = nodeAsString(this.metastatementNode, tokens),
|
|
46
|
+
statementString = nodeAsString(this.statementNode, tokens),
|
|
36
47
|
metastatement = metastatementString, ///
|
|
48
|
+
statement = statementString, ///
|
|
37
49
|
json = {
|
|
38
|
-
metastatement
|
|
50
|
+
metastatement,
|
|
51
|
+
statement
|
|
39
52
|
};
|
|
40
53
|
|
|
41
54
|
return json;
|
|
42
55
|
}
|
|
43
56
|
|
|
44
57
|
static fromMetastatementNode(metastatementNode) {
|
|
45
|
-
const
|
|
58
|
+
const statementNode = null,
|
|
59
|
+
metaConsequent = new MetaConsequent(metastatementNode, statementNode);
|
|
60
|
+
|
|
61
|
+
return metaConsequent;
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
static fromStatementNode(statementNode) {
|
|
65
|
+
const metastatementNode = null,
|
|
66
|
+
metaConsequent = new MetaConsequent(metastatementNode, statementNode);
|
|
46
67
|
|
|
47
68
|
return metaConsequent;
|
|
48
69
|
}
|
|
49
70
|
|
|
50
71
|
static fromJSONAndFileContext(json, fileContext) {
|
|
51
|
-
const { metastatement } = json,
|
|
72
|
+
const { metastatement, statement } = json,
|
|
52
73
|
metastatementString = metastatement, ///
|
|
74
|
+
statementString = statement, ///
|
|
53
75
|
lexer = fileContext.getLexer(),
|
|
54
76
|
parser = fileContext.getParser(),
|
|
55
77
|
metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
|
|
56
|
-
|
|
78
|
+
statementNode = statementNodeFromStatementString(statementString, lexer, parser),
|
|
79
|
+
metaConsequent = new MetaConsequent(metastatementNode, statementNode);
|
|
57
80
|
|
|
58
81
|
return metaConsequent;
|
|
59
82
|
}
|
package/src/metaSupposition.js
CHANGED
|
@@ -6,7 +6,7 @@ import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
|
|
|
6
6
|
import { match } from "./utilities/array";
|
|
7
7
|
import { nodeAsString } from "./utilities/string";
|
|
8
8
|
import { nodeQuery, nodesQuery } from "./utilities/query";
|
|
9
|
-
import { metastatementNodeFromMetastatementString } from "./utilities/node";
|
|
9
|
+
import { statementNodeFromStatementString, metastatementNodeFromMetastatementString } from "./utilities/node";
|
|
10
10
|
|
|
11
11
|
const subproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion!"),
|
|
12
12
|
subproofAssertionMetastatementNodesQuery = nodesQuery("/subproofAssertion/metastatement"),
|
|
@@ -14,88 +14,113 @@ const subproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion!"
|
|
|
14
14
|
metaSubproofLastMetaProofStepMetastatementNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation/lastMetaProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!");
|
|
15
15
|
|
|
16
16
|
export default class MetaSupposition {
|
|
17
|
-
constructor(metastatementNode) {
|
|
17
|
+
constructor(metastatementNode, statementNode) {
|
|
18
18
|
this.metastatementNode = metastatementNode;
|
|
19
|
+
this.statementNode = statementNode;
|
|
19
20
|
}
|
|
20
21
|
|
|
21
22
|
getMetastatementNode() {
|
|
22
23
|
return this.metastatementNode;
|
|
23
24
|
}
|
|
24
25
|
|
|
26
|
+
getStatementNode() {
|
|
27
|
+
return this.statementNode;
|
|
28
|
+
}
|
|
29
|
+
|
|
25
30
|
matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext) {
|
|
26
31
|
let metaSubproofNodeMatches = false;
|
|
27
32
|
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
33
|
+
if (this.metastatementNode !== null) {
|
|
34
|
+
const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
|
|
35
|
+
|
|
36
|
+
if (subproofAssertionNode !== null) {
|
|
37
|
+
const metaSubproofMetaSuppositionMetastatementNodes = metaSubproofMetaSuppositionMetastatementNodesQuery(metaSubproofNode),
|
|
38
|
+
metaSubproofLastMetaProofStepMetastatementNode = metaSubproofLastMetaProofStepMetastatementNodeQuery(metaSubproofNode),
|
|
39
|
+
metaSubproofMetastatementNodes = [
|
|
40
|
+
...metaSubproofMetaSuppositionMetastatementNodes,
|
|
41
|
+
metaSubproofLastMetaProofStepMetastatementNode
|
|
42
|
+
],
|
|
43
|
+
subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
|
|
44
|
+
|
|
45
|
+
metaSubproofNodeMatches = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
|
|
46
|
+
const nonTerminalNodeA = subproofAssertionMetastatementNode, ///
|
|
47
|
+
nonTerminalNodeB = ruleSubproofMetastatementNode, ///
|
|
48
|
+
fileContextA = fileContext, ///
|
|
49
|
+
localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
|
|
50
|
+
localMetaContextB = localMetaContext, ///
|
|
51
|
+
nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
|
|
52
|
+
const verifiedAhead = true;
|
|
53
|
+
|
|
54
|
+
return verifiedAhead;
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
if (nonTerminalNodeVerified) {
|
|
58
|
+
return true;
|
|
59
|
+
}
|
|
60
|
+
});
|
|
61
|
+
}
|
|
55
62
|
}
|
|
56
63
|
|
|
57
64
|
return metaSubproofNodeMatches;
|
|
58
65
|
}
|
|
59
66
|
|
|
60
67
|
matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
68
|
+
let metastatementNodeMatches = false;
|
|
69
|
+
|
|
70
|
+
if (this.metastatementNode !== null) {
|
|
71
|
+
const nonTerminalNodeA = this.metastatementNode, ///
|
|
72
|
+
nonTerminalNodeB = metastatementNode, ///
|
|
73
|
+
fileContextA = fileContext, ///
|
|
74
|
+
localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
|
|
75
|
+
localMetaContextB = localMetaContext, ///
|
|
76
|
+
nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
|
|
77
|
+
const verifiedAhead = true;
|
|
78
|
+
|
|
79
|
+
return verifiedAhead;
|
|
80
|
+
});
|
|
81
|
+
|
|
82
|
+
metastatementNodeMatches = nonTerminalNodeVerified; ///
|
|
83
|
+
}
|
|
72
84
|
|
|
73
85
|
return metastatementNodeMatches;
|
|
74
86
|
}
|
|
75
87
|
|
|
76
88
|
toJSON(tokens) {
|
|
77
89
|
const metastatementString = nodeAsString(this.metastatementNode, tokens),
|
|
90
|
+
statementString = nodeAsString(this.statementNode, tokens),
|
|
78
91
|
metastatement = metastatementString, ///
|
|
92
|
+
statement = statementString, ///
|
|
79
93
|
json = {
|
|
80
|
-
metastatement
|
|
94
|
+
metastatement,
|
|
95
|
+
statement
|
|
81
96
|
};
|
|
82
97
|
|
|
83
98
|
return json;
|
|
84
99
|
}
|
|
85
100
|
|
|
86
101
|
static fromMetastatementNode(metastatementNode) {
|
|
87
|
-
const
|
|
102
|
+
const statementNode = null,
|
|
103
|
+
metaSupposition = new MetaSupposition(metastatementNode, statementNode);
|
|
104
|
+
|
|
105
|
+
return metaSupposition;
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
static fromStatementNode(statementNode) {
|
|
109
|
+
const metastatementNode = null,
|
|
110
|
+
metaSupposition = new MetaSupposition(metastatementNode, statementNode);
|
|
88
111
|
|
|
89
112
|
return metaSupposition;
|
|
90
113
|
}
|
|
91
114
|
|
|
92
115
|
static fromJSONAndFileContext(json, fileContext) {
|
|
93
|
-
const { metastatement } = json,
|
|
116
|
+
const { metastatement, statement } = json,
|
|
94
117
|
metastatementString = metastatement, ///
|
|
118
|
+
statementString = statement, ///
|
|
95
119
|
lexer = fileContext.getLexer(),
|
|
96
120
|
parser = fileContext.getParser(),
|
|
97
121
|
metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
|
|
98
|
-
|
|
122
|
+
statementNode = statementNodeFromStatementString(statementString, lexer, parser),
|
|
123
|
+
metaSupposition = new MetaSupposition(metastatementNode, statementNode);
|
|
99
124
|
|
|
100
125
|
return metaSupposition;
|
|
101
126
|
}
|