@@ -63,6 +63,9 @@ import Kore.Internal.TermLike
63
63
, termLikeSort
64
64
)
65
65
import qualified Kore.Internal.TermLike as TermLike
66
+ import Kore.Rewriting.RewritingVariable
67
+ ( RewritingVariableName
68
+ )
66
69
import qualified Kore.Step.Simplification.AndPredicates as And
67
70
import Kore.Step.Simplification.CeilSimplifier
68
71
import qualified Kore.Step.Simplification.Equals as Equals
@@ -87,13 +90,12 @@ type MkNotMember normalized variable =
87
90
-> Predicate variable
88
91
89
92
newSetCeilSimplifier
90
- :: forall variable simplifier
91
- . InternalVariable variable
92
- => MonadReader (SideCondition variable ) simplifier
93
+ :: forall simplifier
94
+ . MonadReader (SideCondition RewritingVariableName ) simplifier
93
95
=> MonadSimplify simplifier
94
96
=> CeilSimplifier simplifier
95
- (BuiltinAssocComm NormalizedSet variable )
96
- (OrCondition variable )
97
+ (BuiltinAssocComm NormalizedSet RewritingVariableName )
98
+ (OrCondition RewritingVariableName )
97
99
newSetCeilSimplifier =
98
100
CeilSimplifier $ \ ceil@ Ceil { ceilChild } -> do
99
101
let mkInternalAc normalizedAc =
@@ -114,13 +116,12 @@ newSetCeilSimplifier =
114
116
ceil
115
117
116
118
newMapCeilSimplifier
117
- :: forall variable simplifier
118
- . InternalVariable variable
119
- => MonadReader (SideCondition variable ) simplifier
119
+ :: forall simplifier
120
+ . MonadReader (SideCondition RewritingVariableName ) simplifier
120
121
=> MonadSimplify simplifier
121
122
=> CeilSimplifier simplifier
122
- (BuiltinAssocComm NormalizedMap variable )
123
- (OrCondition variable )
123
+ (BuiltinAssocComm NormalizedMap RewritingVariableName )
124
+ (OrCondition RewritingVariableName )
124
125
newMapCeilSimplifier =
125
126
CeilSimplifier $ \ ceil@ Ceil { ceilChild } -> do
126
127
let mkInternalAc normalizedAc =
@@ -173,22 +174,22 @@ generalizeMapElement freeVariables' element =
173
174
variable = refreshElementVariable avoiding x & fromMaybe x
174
175
175
176
newBuiltinAssocCommCeilSimplifier
176
- :: forall normalized variable simplifier
177
- . InternalVariable variable
178
- => MonadReader (SideCondition variable ) simplifier
177
+ :: forall normalized simplifier
178
+ . MonadReader (SideCondition RewritingVariableName ) simplifier
179
179
=> MonadSimplify simplifier
180
180
=> Traversable (Value normalized )
181
181
=> AcWrapper normalized
182
- => MkBuiltinAssocComm normalized variable
183
- -> MkNotMember normalized variable
182
+ => MkBuiltinAssocComm normalized RewritingVariableName
183
+ -> MkNotMember normalized RewritingVariableName
184
184
-> CeilSimplifier simplifier
185
- (BuiltinAssocComm normalized variable )
186
- (OrCondition variable )
185
+ (BuiltinAssocComm normalized RewritingVariableName )
186
+ (OrCondition RewritingVariableName )
187
187
newBuiltinAssocCommCeilSimplifier mkBuiltin mkNotMember =
188
188
CeilSimplifier $ \ Ceil { ceilChild } -> do
189
189
let internalAc@ InternalAc { builtinAcChild } = ceilChild
190
190
sideCondition <- Reader. ask
191
- let normalizedAc :: NormalizedAc normalized Key (TermLike variable )
191
+ let normalizedAc
192
+ :: NormalizedAc normalized Key (TermLike RewritingVariableName )
192
193
normalizedAc = unwrapAc builtinAcChild
193
194
NormalizedAc
194
195
{ elementsWithVariables = abstractElements
@@ -198,9 +199,9 @@ newBuiltinAssocCommCeilSimplifier mkBuiltin mkNotMember =
198
199
= normalizedAc
199
200
200
201
let defineOpaquePair
201
- :: TermLike variable
202
- -> TermLike variable
203
- -> MultiAnd (OrCondition variable )
202
+ :: TermLike RewritingVariableName
203
+ -> TermLike RewritingVariableName
204
+ -> MultiAnd (OrCondition RewritingVariableName )
204
205
defineOpaquePair opaque1 opaque2 =
205
206
internalAc
206
207
{ builtinAcChild =
@@ -217,37 +218,40 @@ newBuiltinAssocCommCeilSimplifier mkBuiltin mkNotMember =
217
218
& MultiAnd. singleton
218
219
219
220
defineOpaquePairs
220
- :: TermLike variable
221
- -> [TermLike variable ]
222
- -> MultiAnd (OrCondition variable )
221
+ :: TermLike RewritingVariableName
222
+ -> [TermLike RewritingVariableName ]
223
+ -> MultiAnd (OrCondition RewritingVariableName )
223
224
defineOpaquePairs this others =
224
225
foldMap (defineOpaquePair this) others
225
226
226
- definedOpaquePairs :: MultiAnd (OrCondition variable )
227
+ definedOpaquePairs :: MultiAnd (OrCondition RewritingVariableName )
227
228
definedOpaquePairs =
228
229
mconcat
229
230
$ zipWith defineOpaquePairs opaque
230
231
$ tail $ List. tails opaque
231
232
232
233
let abstractKeys, concreteKeys
233
- :: [TermLike variable ]
234
+ :: [TermLike RewritingVariableName ]
234
235
abstractValues, concreteValues, allValues
235
- :: [Value normalized (TermLike variable )]
236
+ :: [Value normalized (TermLike RewritingVariableName )]
236
237
(abstractKeys, abstractValues) =
237
238
unzip (unwrapElement <$> abstractElements)
238
239
concreteKeys = from @ Key <$> Map. keys concreteElements
239
240
concreteValues = Map. elems concreteElements
240
241
allValues = concreteValues <> abstractValues
241
242
242
243
let makeEvaluateTerm, defineAbstractKey, defineOpaque
243
- :: TermLike variable -> MaybeT simplifier (OrCondition variable )
244
+ :: TermLike RewritingVariableName
245
+ -> MaybeT simplifier (OrCondition RewritingVariableName )
244
246
makeEvaluateTerm = makeEvaluateTermCeil sideCondition
245
247
defineAbstractKey = makeEvaluateTerm
246
248
defineOpaque = makeEvaluateTerm
247
249
248
250
defineValue
249
- :: Value normalized (TermLike variable )
250
- -> MaybeT simplifier (MultiAnd (OrCondition variable ))
251
+ :: Value normalized (TermLike RewritingVariableName )
252
+ -> MaybeT
253
+ simplifier
254
+ (MultiAnd (OrCondition RewritingVariableName ))
251
255
defineValue = foldlM worker mempty
252
256
where
253
257
worker multiAnd termLike = do
@@ -267,7 +271,7 @@ newBuiltinAssocCommCeilSimplifier mkBuiltin mkNotMember =
267
271
zipWithM distinctKey
268
272
abstractKeys
269
273
(tail $ List. tails abstractKeys)
270
- let conditions :: MultiAnd (OrCondition variable )
274
+ let conditions :: MultiAnd (OrCondition RewritingVariableName )
271
275
conditions =
272
276
mconcat
273
277
[ MultiAnd. make definedKeys
@@ -283,16 +287,16 @@ newBuiltinAssocCommCeilSimplifier mkBuiltin mkNotMember =
283
287
where
284
288
285
289
distinctKey
286
- :: TermLike variable
287
- -> [TermLike variable ]
288
- -> MaybeT simplifier (MultiAnd (OrCondition variable ))
290
+ :: TermLike RewritingVariableName
291
+ -> [TermLike RewritingVariableName ]
292
+ -> MaybeT simplifier (MultiAnd (OrCondition RewritingVariableName ))
289
293
distinctKey thisKey otherKeys =
290
294
MultiAnd. make <$> traverse (notEquals thisKey) otherKeys
291
295
292
296
notEquals
293
- :: TermLike variable
294
- -> TermLike variable
295
- -> MaybeT simplifier (OrCondition variable )
297
+ :: TermLike RewritingVariableName
298
+ -> TermLike RewritingVariableName
299
+ -> MaybeT simplifier (OrCondition RewritingVariableName )
296
300
notEquals t1 t2 = do
297
301
sideCondition <- Reader. ask
298
302
Equals. makeEvaluateTermsToPredicate tMin tMax sideCondition
@@ -302,18 +306,18 @@ newBuiltinAssocCommCeilSimplifier mkBuiltin mkNotMember =
302
306
(tMin, tMax) = minMax t1 t2
303
307
304
308
notMember
305
- :: TermLike variable
306
- -> Element normalized (TermLike variable )
307
- -> MultiAnd (OrCondition variable )
309
+ :: TermLike RewritingVariableName
310
+ -> Element normalized (TermLike RewritingVariableName )
311
+ -> MultiAnd (OrCondition RewritingVariableName )
308
312
notMember termLike element =
309
313
mkNotMember element termLike
310
314
& OrCondition. fromPredicate
311
315
& MultiAnd. singleton
312
316
313
317
notMembers
314
- :: NormalizedAc normalized Key (TermLike variable )
315
- -> TermLike variable
316
- -> MultiAnd (OrCondition variable )
318
+ :: NormalizedAc normalized Key (TermLike RewritingVariableName )
319
+ -> TermLike RewritingVariableName
320
+ -> MultiAnd (OrCondition RewritingVariableName )
317
321
notMembers normalizedAc termLike =
318
322
Lens. foldMapOf foldElements (notMember termLike) normalizedAc
319
323
0 commit comments