How to substitute a function body in z3py? - z3

Question

I have a z3 function, e.g., zero = [else → Epoch!val!2], where Epoch!val!2 is a constant of sort Epoch. I want to get a new function zero(m) = [else -> Epoch!val!2(m)], where I'm basically introducing an argument m as the first parameter in every function in the body.
In SMT-Lib speak, I want to go from the following:
(declare-sort Epoch)
(declare-fun Epoch!val!2 () Epoch)
(define-fun zero () Epoch
(Epoch!val!2)
)
to the following:
(declare-sort M)
(declare-sort Epoch)
(declare-fun Epoch!val!2 (M) Epoch)
(define-fun zero ((m M)) Epoch
(Epoch!val!2 m)
)
I tried to use the substitute function, but that only accepts z3 expressions, whereas I have zero from the model, i.e., as a FuncInterp instance. I'm not sure how to convert that into an expression, and couldn't find docs for that.
What should I do?
Edit: Adding more context.
I'm trying to write a CEGIS tool with SAT-based-synthesis (as opposed to enumerated synthesis), but here counter examples are entire models (including uninterpreted functions) rather than simpler entities. So, for example, the generated counter example might be:
(declare-sort Epoch)
(declare-fun Epoch!Val!0 () Epoch)
(declare-fun Epoch!Val!1 () Epoch)
(declare-fun Epoch!Val!2 () Epoch)
(define-fun le ((e1 Epoch) (e2 Epoch)) Bool
(ite (and (= x!0 Epoch!val!0) (= x!1 Epoch!val!1))
false
(ite (and (= x!0 Epoch!val!0) (= x!1 Epoch!val!2))
false
(ite (and (= x!0 Epoch!val!2) (= x!1 Epoch!val!1))
false
true))))
As you can see, the model declares its universe, and gives the definition of le.
Since this is CEGIS, I will have multiple such models (counter examples). Since this is SAT based synthesis, I am encoding these counter examples into a SAT (well, SMT) query, and asking the solver to synthesize my function. Say, I know the template of the function I'm synthesizing, and it is either le(Epoch, Epoch) or not(le(Epoch, Epoch)). Then I will encode this as an SMT query like below:
<declarations>
(declare-const rev_ord Bool)
(declare-const to_not Bool)
(define-fun inv ((e1 Epoch) (e2 Epoch)) Bool
(ite (and (not rev_ord) (not to_not))
(le e1 e2)
(ite (and (not rev_ord) to_not)
(not (le e1 e2))
(ite (and rev_ord (not to_not))
(le e2 e1)
(ite (and rev_ord to_not)
(not (le e2 e1))
)))))
<constraints??>
(check-sat)
(get-value rev_ord to_not)
Here, encoding the constraints is the tricky part. If I have two counter examples, I want two constraints, each asserting that the synthesized function satisfies the counter example model. To encode the constraints, I've decided that the best approach ahead is to write the SAT query like this:
(declare-sort ModelId)
(declare-sort Epoch)
(declare-fun M0 () ModelId)
(declare-fun M1 () ModelId)
(declare-fun Epoch!val!1 (ModelId) Epoch)
(declare-fun Epoch!val!2 (ModelId) Epoch)
(declare-fun Epoch!val!0 (ModelId) Epoch)
(declare-const rev_ord Bool)
(declare-const to_not Bool)
;;
;; Notice the addition of the model id
;;
(define-fun inv ((m ModelId) (e1 Epoch) (e2 Epoch)) Bool
(ite (and (not rev_ord) (not to_not))
(le m e1 e2)
(ite (and (not rev_ord) to_not)
(not (le m e1 e2))
(ite (and rev_ord (not to_not))
(le m e2 e1)
(ite (and rev_ord to_not)
(not (le m e2 e1))
)))))
; counter example 1.
; Format: (and <model_description> <function_requirements>)
(assert (and
(and
(= (le (Epoch!val!0 M0) (Epoch!val!1 M0)) false)
(= (le (Epoch!val!0 M0) (Epoch!val!2 M0)) false)
(= (le (Epoch!val!2 M0) (Epoch!val!1 M0)) true)
)
(and
(inv M0 (Epoch!val!0 M0) (Epoch!val!1 M0))
(inv M0 (Epoch!val!0 M0) (Epoch!val!2 M0))
(inv M0 (Epoch!val!2 M0) (Epoch!val!1 M0))
)
))
; similarly, counter example 2
(check-sat)
(get-value rev_ord to_not)
To summarize: I get counter example models, which I want to feed into a synthesis query, but I want to tag the model's uninterpreted functions and constants with that model's "ID", so that the synthesis engine doesn't give me meaningless functions.