How to define an inductive predicate on fset?

Question

I defined 2 kinds of values and a cast function:

theory FSetIndTest
  imports Main "~~/src/HOL/Library/FSet"
begin

datatype val1 = A | B
datatype val2 = C | D

inductive cast_val :: "val1 ⇒ val2 ⇒ bool" where
  "cast_val A C"
| "cast_val B D"

Also, I defined cast function for a list of values:

inductive cast_list :: "val1 list ⇒ val2 list ⇒ bool" where
  "cast_list [] []"
| "cast_val x y ⟹ cast_list xs ys ⟹ cast_list (x#xs) (y#ys)"

code_pred [show_modes] cast_list .

values "{x. cast_list [A, B] x}"
values "{x. cast_list x [C, D]}"

I need to define a similar function for fset.

Here is a 1st attempt. It seems that the generated implementation is non-terminating:

inductive cast_fset1 :: "val1 fset ⇒ val2 fset ⇒ bool" where
  "cast_fset1 {||} {||}"
| "cast_val x y ⟹ cast_fset1 xs ys ⟹
   cast_fset1 (finsert x xs) (finsert y ys)"

code_pred [show_modes] cast_fset1 .

(*values "{x. cast_fset1 {|A, B|} x}"*)

Here is another attempt. It doesn't allow to calculate second argument given the 1st argument:

inductive cast_fset2 :: "val1 fset ⇒ val2 fset ⇒ bool" where
  "⋀x y. x |∈| xs ⟹ y |∈| ys ⟹ cast_val x y ⟹
   cast_fset2 xs ys"

code_pred [show_modes] cast_fset2 .

The following version works fine, but it use a functional cast_val_fun instead of inductive cast_val. And also it works only in one direction:

fun cast_val_fun :: "val1 ⇒ val2" where
  "cast_val_fun A = C"
| "cast_val_fun B = D"

inductive cast_fset3 :: "val1 fset ⇒ val2 fset ⇒ bool" where
  "cast_fset3 x (fimage cast_val_fun x)"

code_pred [show_modes] cast_fset3 .

values "{x. cast_fset3 {|A, B|} x}"

Here is one more non-terminating implementation:

inductive cast_fset4 :: "val1 fset ⇒ val2 fset ⇒ bool" where
  "cast_list xs ys ⟹
   cast_fset4 (fset_of_list xs) (fset_of_list ys)"

code_pred [show_modes] cast_fset4 .

(*values "{x. cast_fset4 {|A, B|} x}"*)

Could you suggest how to define an inductive version of the cast function for fsets with terminating implementation?

UPDATE:

The following code is generated for cast_fset1:

  cast_fset1_o_o =
  sup (Predicate.bind (Predicate.single ()) (λx. case x of () ⇒ Predicate.single ({||}, {||})))
   (Predicate.bind (Predicate.single ())
     (λx. case x of
          () ⇒
            Predicate.bind cast_fset1_o_o
             (λx. case x of
                  (xs_, ys_) ⇒
                    Predicate.bind cast_val_o_o
                     (λxa. case xa of
                           (x_, y_) ⇒ Predicate.single (finsert x_ xs_, finsert y_ ys_)))))

  cast_fset1_i_o ?xa =
  sup (Predicate.bind (Predicate.single ?xa)
        (λx. if x = {||} then Predicate.single {||} else bot))
   (Predicate.bind (Predicate.single ?xa)
     (λx. Predicate.bind cast_fset1_o_o
           (λxa. case xa of
                 (xs_, ys_) ⇒
                   Predicate.bind cast_val_o_o
                    (λxb. case xb of
                          (xa_, y_) ⇒
                            if x = finsert xa_ xs_ then Predicate.single (finsert y_ ys_)
                            else bot))))

cast_fset1_i_o invokes cast_fset1_o_o. The later one is non-terminating. I think it's because fset doesn't have any constructors. But I don't understand how to fix it. How to generate code for datatypes without constructors?

UPDATE 2:

The same behavior for multisets:

code_pred [show_modes] rel_mset' .

values 2 "{x. (rel_mset' cast_val) {#A, B#} x}"

returns {mset [D, C], mset [C, D]} ∪ ...

mset [D, C] and mset [C, D] are equal. Abs_fset {D, C} and Abs_fset {C, D} returned by the following expression are equal too:

values 2 "{x. cast_fset1 {|A, B|} x}"

How to define an inductive predicate for fset, multiset, ... so it calculates sets with some canonicial list representation and doesn't return duplicate values?