unfolding | A library to create interactive maps and geovisualizations | Map library

Found it! You gotta put the class in the accordion-body. So at first define a class like

In principle, that kind of approach does work: if you have a function f from a set A to a set B and an inverse function to it, you can prove bij_betw f A B (read: f is a bijection from A to B), and that then implies card A = card B.

However, there are a few comments that I have:

1. You should use bool lists instead of nat lists if you can only have 0 or 1 in them anyway.

2. It is usually better to use existing library functions than to define new ones yourself. Your two functions could be defined using library functions like this:

The Vue 3 documentation has a Migration Build example. Follow their steps and maybe you'll find out where it went wrong.

Another solution might be to create the Vue 3 project from scratch, re-do the setups for router, store, vueconfig, etc, and then migrate your components and views one by one.

The documentation tries to be as clear as possible in the main differences between Vue 2 and Vue 3, so check the docs for a more precise explanation of it.

Yes, generally speaking this is possible but only if your class AnyType would be a template class. In this case you could disable the operator<< directly with std::enable_if. As in your case which precise variable type is held by the shared pointer inside AnyType is decided on runtime you can't simply disable it with SFINAE. What you can do though is use a type-trait inside the virtual method to decide if the stream should be modified or not depending on the template parameter VariableType of VariableHolder:

Just define a type-trait is_streamable as follows

Is because your after has content Afficher toutes les infos only when button has class collapsed and your HTML start without this class, so you just need add the collapsed class in default html, right there:

I suppose, there are two distinct parts in your question, first one is why you need to permute, and second how two unfolds combined produce square image slices.

First moment is rather technical - unfold places produced slices in the new dimension of tensor, being 'inserted at the end of the shape'. permute here is needed to place it near channel or depth dimension, for merging them natural way using view later.

Now second part. Consider a deck of imaginary cards, each card is a picture channel. Take a card and cut it on vertical slices, then place slices on top of each other. Take a second card and do the same, placing result on the first one, do it with all cards. Now repeat the procedure, with cutting slices horisontaly. At the end you have much thinner but taller deck, where former cards become subdecks of patches.

lemma bij_iff_ex_identity : "bij_betw f A B ⟷ (∃ g. g∘f = restrict id B ∧ f∘g = restrict id A)"

I think this is not exactly what you want an I am doubtful that it is true. g∘f = restrict id B does not mean that g∘f and id are equal on B. It means that the total function g∘f (and there are only total functions in HOL) equals the total function restrict id B. The latter returns id x on x∈B and undefined otherwise. So to make this equality true, g needs to output undefined whenever the input of f is not in B. But how would g know that!

If you want to use restrict, you could write restrict (g∘f) B = restrict id B. But personally, I would rather go for the simpler (∀x∈B. (g∘f) x = x).

So the corrected theorem would be:

lemma bij_iff_ex_identity : "bij_betw f A B ⟷ (∃ g. (∀x∈A. (g∘f) x = x) ∧ (∀y∈B. (f∘g) y = y))"

(Which is still wrong, by the way, as quickcheck tells me in Isabelle/jEdit, see the output window. If A has one element and B is empty, f cannot be a bijection. So the theorem you are attempting is actually mathematically not true. I will not attempt to fix it, but just answer the remaining lines.

unfolding bij_betw_def inj_on_def restrict_def iffI

The iffI here has no effect. Unfolding can only apply theorems of the form A = B (unconditional rewriting rules). iffI is not of that form. (Use thm iffI to see.)

proof

Personally, I don't use the bare form proof but always proof - or proof (some method). Because proof just applies some default method (in this case, equivalent to (rule iffI), so I think it's better to make it explicit. proof - just starts the proof without applying an extra method.

let ?g = "restrict (λ y. (if f x = y then x else undefined)) B"

You have an unbound variable x here. (Note the background color in the IDE.) That is most likely not what you want. Formally, it is allowed, but x will be treated as if it was some arbitrary constant.

Generally, I don't think there is any way to define g in a simple way (i.e., only with quantifiers and function applications and if-then-else). I think the only way to define an inverse (even if you know it exists), is to use the THE operator, because you need to say something like g y is "the" x such that f x = y. (And then later in the proof you will run into a proof obligation that it indeed exists and that it is unique.) See the definition of inv_into in Hilbert_Choice.thy (except it uses SOME not THE). Maybe for starters, try to do the proof just using the existing inv_into constant.

assume "(∀x∈A. ∀y∈A. f x = f y ⟶ x = y)"

All assume commands must have assumptions exactly as the are in the proof goal. You can test whether you wrote it right by just temporarily writing the command show A for A (that's an unprovable goal that would, however, finish the proof, so it tricks Isabelle into checking if it would). If this command does not give an error, you got the assumes right. In your cases, you didn't, it should be (∀x∈A. ∀y∈A. f x = f y ⟶ x = y) ∧ f ' A = B. (' is the backtick symbol here. Markup doesn't let me write it.)

My recommendation: Try the proof with bij instead of bij_betw first. (One direction is in BNF_Fixpoint_Base.o_bij if you want to cheat.) Once done, you can try to generalize.

It might fail because the conclusion of E_Ass does not immediately match your goal. auto does check this upfront and does not even try to apply a lemma if the conclusion does not directly match. Afair fail includes "didn't try". Even simple_apply does some conversion between the applied lemma and the goal. You can try to add a hint with a variant of E_Ass, which is converted to match the goal. What is the type of E_Ass?

Unfortunately my usual trend of Boost.Mp11 one-liners will come to an end here, since Boost.Mp11 doesn't really deal with values very well and we need to convert int[5][12] into mdarray and there's no easy mechanism to do that with that library.

Instead we just do it by hand. std::extent gives you the Nth extent and std::rank gives you the number of extents. Combine that with make_index_sequence and you can get all of 'em: