fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
@[elab_as_elim]
nilElim {C : Vector3 α 0 → Sort u} (H : C []) (v : Vector3 α 0) : C v := by
rw [eq_nil v]; apply H | def | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | nilElim | Eliminator for an empty vector. |
@[elab_as_elim]
consElim {C : Vector3 α (n + 1) → Sort u} (H : ∀ (a : α) (t : Vector3 α n), C (a :: t))
(v : Vector3 α (n + 1)) : C v := by rw [← cons_head_tail v]; apply H
@[simp] | def | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | consElim | Recursion principle for a nonempty vector. |
consElim_cons {C H a t} : @consElim α n C H (a :: t) = H a t :=
rfl | theorem | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | consElim_cons | null |
@[elab_as_elim]
protected recOn {C : ∀ {n}, Vector3 α n → Sort u} {n} (v : Vector3 α n) (H0 : C [])
(Hs : ∀ {n} (a) (w : Vector3 α n), C w → C (a :: w)) : C v :=
match n with
| 0 => v.nilElim H0
| _ + 1 => v.consElim fun a t => Hs a t (Vector3.recOn t H0 Hs)
@[simp] | def | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | recOn | Recursion principle with the vector as first argument. |
recOn_nil {C H0 Hs} : @Vector3.recOn α (@C) 0 [] H0 @Hs = H0 :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | recOn_nil | null |
recOn_cons {C H0 Hs n a v} :
@Vector3.recOn α (@C) (n + 1) (a :: v) H0 @Hs = Hs a v (@Vector3.recOn α (@C) n v H0 @Hs) :=
rfl | theorem | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | recOn_cons | null |
append (v : Vector3 α m) (w : Vector3 α n) : Vector3 α (n + m) :=
v.recOn w (fun a _ IH => a :: IH) | def | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | append | Append two vectors |
insert (a : α) (v : Vector3 α n) (i : Fin2 (n + 1)) : Vector3 α (n + 1) := fun j =>
(a :: v) (insertPerm i j)
@[simp] | def | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | insert | A local infix notation for `Vector3.append`
-/
local infixl:65 " +-+ " => Vector3.append
@[simp]
theorem append_nil (w : Vector3 α n) : [] +-+ w = w :=
rfl
@[simp]
theorem append_cons (a : α) (v : Vector3 α m) (w : Vector3 α n) : (a :: v) +-+ w = a :: v +-+ w :=
rfl
@[simp]
theorem append_left :
∀ {m} (i : Fin2 m) (v : Vector3 α m) {n} (w : Vector3 α n), (v +-+ w) (left n i) = v i
| _, @fz m, v, _, _ => v.consElim fun a _t => by simp [*, left]
| _, @fs m i, v, n, w => v.consElim fun _a t => by simp [append_left, left]
@[simp]
theorem append_add :
∀ {m} (v : Vector3 α m) {n} (w : Vector3 α n) (i : Fin2 n), (v +-+ w) (add i m) = w i
| 0, _, _, _, _ => rfl
| m + 1, v, n, w, i => v.consElim fun _a t => by simp [append_add, add]
/-- Insert `a` into `v` at index `i`. |
insert_fz (a : α) (v : Vector3 α n) : insert a v fz = a :: v := by
refine funext fun j => j.cases' ?_ ?_ <;> intros <;> rfl
@[simp] | theorem | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | insert_fz | null |
insert_fs (a : α) (b : α) (v : Vector3 α n) (i : Fin2 (n + 1)) :
insert a (b :: v) (fs i) = b :: insert a v i :=
funext fun j => by
refine j.cases' (by simp [insert, insertPerm]) fun j => ?_
simp only [insert, insertPerm, succ_eq_add_one, cons_fs]
refine Fin2.cases' ?_ ?_ (insertPerm i j) <;> simp | theorem | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | insert_fs | null |
append_insert (a : α) (t : Vector3 α m) (v : Vector3 α n) (i : Fin2 (n + 1))
(e : (n + 1) + m = (n + m) + 1) :
insert a (t +-+ v) (Eq.recOn e (i.add m)) = Eq.recOn e (t +-+ insert a v i) := by
refine Vector3.recOn t (fun e => ?_) (@fun k b t IH _ => ?_) e
· rfl
have e' : (n + 1) + k = (n + k) + 1 := by omega
change
insert a (b :: t +-+ v)
(Eq.recOn (congr_arg (· + 1) e' : _ + 1 = _) (fs (add i k))) =
Eq.recOn (congr_arg (· + 1) e' : _ + 1 = _) (b :: t +-+ insert a v i)
rw [← (Eq.recOn e' rfl :
fs (Eq.recOn e' (i.add k) : Fin2 ((n + k) + 1)) =
Eq.recOn (congr_arg (· + 1) e' : _ + 1 = _) (fs (i.add k)))]
simpa [IH] using Eq.recOn e' rfl | theorem | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | append_insert | null |
VectorEx : ∀ k, (Vector3 α k → Prop) → Prop
| 0, f => f []
| succ k, f => ∃ x : α, VectorEx k fun v => f (x :: v) | def | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | VectorEx | "Curried" exists, i.e. `∃ x₁ ... xₙ, f [x₁, ..., xₙ]`. |
VectorAll : ∀ k, (Vector3 α k → Prop) → Prop
| 0, f => f []
| succ k, f => ∀ x : α, VectorAll k fun v => f (x :: v) | def | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | VectorAll | "Curried" forall, i.e. `∀ x₁ ... xₙ, f [x₁, ..., xₙ]`. |
exists_vector_zero (f : Vector3 α 0 → Prop) : Exists f ↔ f [] :=
⟨fun ⟨v, fv⟩ => by rw [← eq_nil v]; exact fv, fun f0 => ⟨[], f0⟩⟩ | theorem | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | exists_vector_zero | null |
exists_vector_succ (f : Vector3 α (succ n) → Prop) : Exists f ↔ ∃ x v, f (x :: v) :=
⟨fun ⟨v, fv⟩ => ⟨_, _, by rw [cons_head_tail v]; exact fv⟩, fun ⟨_, _, fxv⟩ => ⟨_, fxv⟩⟩ | theorem | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | exists_vector_succ | null |
vectorEx_iff_exists : ∀ {n} (f : Vector3 α n → Prop), VectorEx n f ↔ Exists f
| 0, f => (exists_vector_zero f).symm
| succ _, f =>
Iff.trans (exists_congr fun _ => vectorEx_iff_exists _) (exists_vector_succ f).symm | theorem | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | vectorEx_iff_exists | null |
vectorAll_iff_forall : ∀ {n} (f : Vector3 α n → Prop), VectorAll n f ↔ ∀ v, f v
| 0, _ => ⟨fun f0 v => v.nilElim f0, fun al => al []⟩
| succ _, f =>
(forall_congr' fun x => vectorAll_iff_forall fun v => f (x :: v)).trans
⟨fun al v => v.consElim al, fun al x v => al (x :: v)⟩ | theorem | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | vectorAll_iff_forall | null |
VectorAllP (p : α → Prop) (v : Vector3 α n) : Prop :=
Vector3.recOn v True fun a v IH =>
@Vector3.recOn _ (fun _ => Prop) _ v (p a) fun _ _ _ => p a ∧ IH
@[simp] | def | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | VectorAllP | `VectorAllP p v` is equivalent to `∀ i, p (v i)`, but unfolds directly to a conjunction,
i.e. `VectorAllP p [0, 1, 2] = p 0 ∧ p 1 ∧ p 2`. |
vectorAllP_nil (p : α → Prop) : VectorAllP p [] = True :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | vectorAllP_nil | null |
vectorAllP_singleton (p : α → Prop) (x : α) : VectorAllP p (cons x []) = p x :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | vectorAllP_singleton | null |
vectorAllP_cons (p : α → Prop) (x : α) (v : Vector3 α n) :
VectorAllP p (x :: v) ↔ p x ∧ VectorAllP p v :=
Vector3.recOn v (iff_of_eq (and_true _)).symm fun _ _ _ => Iff.rfl | theorem | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | vectorAllP_cons | null |
vectorAllP_iff_forall (p : α → Prop) (v : Vector3 α n) :
VectorAllP p v ↔ ∀ i, p (v i) := by
refine v.recOn ?_ ?_
· exact ⟨fun _ => Fin2.elim0, fun _ => trivial⟩
· simp only [vectorAllP_cons]
refine fun {n} a v IH =>
(and_congr_right fun _ => IH).trans
⟨fun ⟨pa, h⟩ i => by
refine i.cases' ?_ ?_
exacts [pa, h], fun h => ⟨?_, fun i => ?_⟩⟩
· simpa using h fz
· simpa using h (fs i) | theorem | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | vectorAllP_iff_forall | null |
VectorAllP.imp {p q : α → Prop} (h : ∀ x, p x → q x) {v : Vector3 α n}
(al : VectorAllP p v) : VectorAllP q v :=
(vectorAllP_iff_forall _ _).2 fun _ => h _ <| (vectorAllP_iff_forall _ _).1 al _ | theorem | Data | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Util.Notation3",
"Mathlib.Tactic.TypeStar"
] | Mathlib/Data/Vector3.lean | VectorAllP.imp | null |
@[deprecated "use instead `contDiffPregroupoid ω`" (since := "2025-04-13")]
analyticPregroupoid : Pregroupoid H where
property f s := AnalyticOn 𝕜 (I ∘ f ∘ I.symm) (I.symm ⁻¹' s ∩ range I)
comp {f g u v} hf hg _ _ _ := by
have : I ∘ (g ∘ f) ∘ I.symm = (I ∘ g ∘ I.symm) ∘ I ∘ f ∘ I.symm := by ext x; simp
simp only [this]
apply hg.comp
· exact hf.mono fun _ ⟨hx1, hx2⟩ ↦ ⟨hx1.1, hx2⟩
· rintro x ⟨hx1, _⟩
simpa only [mfld_simps] using hx1.2
id_mem := by
apply analyticOn_id.congr
rintro x ⟨_, hx2⟩
obtain ⟨y, hy⟩ := mem_range.1 hx2
simp only [mfld_simps, ← hy]
locality {f u} _ H := by
apply analyticOn_of_locally_analyticOn
rintro y ⟨hy1, hy2⟩
obtain ⟨x, hx⟩ := mem_range.1 hy2
simp only [mfld_simps, ← hx] at hy1 ⊢
obtain ⟨v, v_open, xv, hv⟩ := H x hy1
have : I.symm ⁻¹' (u ∩ v) ∩ range I = I.symm ⁻¹' u ∩ range I ∩ I.symm ⁻¹' v := by
rw [preimage_inter, inter_assoc, inter_assoc, inter_comm _ (range I)]
exact ⟨I.symm ⁻¹' v, v_open.preimage I.continuous_symm, by simpa, this ▸ hv⟩
congr {f g u} _ fg hf := by
apply hf.congr
rintro y ⟨hy1, hy2⟩
obtain ⟨x, hx⟩ := mem_range.1 hy2
simp only [mfld_simps, ← hx] at hy1 ⊢
rw [fg _ hy1]
variable (I) in | def | Deprecated | [
"Mathlib.Analysis.Analytic.Constructions",
"Mathlib.Geometry.Manifold.IsManifold.Basic"
] | Mathlib/Deprecated/AnalyticManifold.lean | analyticPregroupoid | Given a model with corners `(E, H)`, we define the pregroupoid of analytic transformations of
`H` as the maps that are `AnalyticOn` when read in `E` through `I`. Using `AnalyticOn`
rather than `AnalyticOnNhd` gives us meaningful definitions at boundary points. |
@[deprecated "use instead `contDiffGroupoid ω`" (since := "2025-04-13")]
analyticGroupoid : StructureGroupoid H :=
(analyticPregroupoid I).groupoid | def | Deprecated | [
"Mathlib.Analysis.Analytic.Constructions",
"Mathlib.Geometry.Manifold.IsManifold.Basic"
] | Mathlib/Deprecated/AnalyticManifold.lean | analyticGroupoid | Given a model with corners `(E, H)`, we define the groupoid of analytic transformations of
`H` as the maps that are `AnalyticOn` when read in `E` through `I`. Using `AnalyticOn`
rather than `AnalyticOnNhd` gives us meaningful definitions at boundary points. |
ofSet_mem_analyticGroupoid {s : Set H} (hs : IsOpen s) :
OpenPartialHomeomorph.ofSet s hs ∈ analyticGroupoid I := by
rw [analyticGroupoid, mem_groupoid_of_pregroupoid]
suffices h : AnalyticOn 𝕜 (I ∘ I.symm) (I.symm ⁻¹' s ∩ range I) by
simp [h, analyticPregroupoid]
have hi : AnalyticOn 𝕜 id (univ : Set E) := analyticOn_id
exact (hi.mono (subset_univ _)).congr (fun x hx ↦ I.right_inv hx.2) | theorem | Deprecated | [
"Mathlib.Analysis.Analytic.Constructions",
"Mathlib.Geometry.Manifold.IsManifold.Basic"
] | Mathlib/Deprecated/AnalyticManifold.lean | ofSet_mem_analyticGroupoid | An identity open partial homeomorphism belongs to the analytic groupoid. |
symm_trans_mem_analyticGroupoid (e : OpenPartialHomeomorph M H) :
e.symm.trans e ∈ analyticGroupoid I :=
haveI : e.symm.trans e ≈ OpenPartialHomeomorph.ofSet e.target e.open_target :=
OpenPartialHomeomorph.symm_trans_self _
StructureGroupoid.mem_of_eqOnSource _ (ofSet_mem_analyticGroupoid e.open_target) this | theorem | Deprecated | [
"Mathlib.Analysis.Analytic.Constructions",
"Mathlib.Geometry.Manifold.IsManifold.Basic"
] | Mathlib/Deprecated/AnalyticManifold.lean | symm_trans_mem_analyticGroupoid | The composition of an open partial homeomorphism from `H` to `M` and its inverse belongs to
the analytic groupoid. |
mem_analyticGroupoid {I : ModelWithCorners 𝕜 E H} {f : OpenPartialHomeomorph H H} :
f ∈ analyticGroupoid I ↔
AnalyticOn 𝕜 (I ∘ f ∘ I.symm) (I.symm ⁻¹' f.source ∩ range I) ∧
AnalyticOn 𝕜 (I ∘ f.symm ∘ I.symm) (I.symm ⁻¹' f.target ∩ range I) := by
rfl | lemma | Deprecated | [
"Mathlib.Analysis.Analytic.Constructions",
"Mathlib.Geometry.Manifold.IsManifold.Basic"
] | Mathlib/Deprecated/AnalyticManifold.lean | mem_analyticGroupoid | The analytic groupoid is closed under restriction. -/
instance : ClosedUnderRestriction (analyticGroupoid I) :=
(closedUnderRestriction_iff_id_le _).mpr
(by
rw [StructureGroupoid.le_iff]
rintro e ⟨s, hs, hes⟩
exact (analyticGroupoid I).mem_of_eqOnSource' _ _ (ofSet_mem_analyticGroupoid hs) hes)
/-- `f ∈ analyticGroupoid` iff it and its inverse are analytic within `range I`. |
mem_analyticGroupoid_of_boundaryless [I.Boundaryless] (e : OpenPartialHomeomorph H H) :
e ∈ analyticGroupoid I ↔ AnalyticOnNhd 𝕜 (I ∘ e ∘ I.symm) (I '' e.source) ∧
AnalyticOnNhd 𝕜 (I ∘ e.symm ∘ I.symm) (I '' e.target) := by
simp only [mem_analyticGroupoid, I.range_eq_univ, inter_univ, I.image_eq]
rw [IsOpen.analyticOn_iff_analyticOnNhd, IsOpen.analyticOn_iff_analyticOnNhd]
· exact I.continuous_symm.isOpen_preimage _ e.open_target
· exact I.continuous_symm.isOpen_preimage _ e.open_source | theorem | Deprecated | [
"Mathlib.Analysis.Analytic.Constructions",
"Mathlib.Geometry.Manifold.IsManifold.Basic"
] | Mathlib/Deprecated/AnalyticManifold.lean | mem_analyticGroupoid_of_boundaryless | The analytic groupoid on a boundaryless charted space modeled on a complete vector space
consists of the open partial homeomorphisms which are analytic and have analytic inverse. |
analyticGroupoid_prod {E A : Type} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
[TopologicalSpace A] {F B : Type} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
[TopologicalSpace B] {I : ModelWithCorners 𝕜 E A} {J : ModelWithCorners 𝕜 F B}
{f : OpenPartialHomeomorph A A} {g : OpenPartialHomeomorph B B}
(fa : f ∈ analyticGroupoid I) (ga : g ∈ analyticGroupoid J) :
f.prod g ∈ analyticGroupoid (I.prod J) := by
have pe : range (I.prod J) = (range I).prod (range J) := I.range_prod
simp only [mem_analyticGroupoid] at fa ga ⊢
exact ⟨AnalyticOn.prod
(fa.1.comp analyticOn_fst fun _ m ↦ ⟨m.1.1, (pe ▸ m.2).1⟩)
(ga.1.comp analyticOn_snd fun _ m ↦ ⟨m.1.2, (pe ▸ m.2).2⟩),
AnalyticOn.prod
(fa.2.comp analyticOn_fst fun _ m ↦ ⟨m.1.1, (pe ▸ m.2).1⟩)
(ga.2.comp analyticOn_snd fun _ m ↦ ⟨m.1.2, (pe ▸ m.2).2⟩)⟩ | theorem | Deprecated | [
"Mathlib.Analysis.Analytic.Constructions",
"Mathlib.Geometry.Manifold.IsManifold.Basic"
] | Mathlib/Deprecated/AnalyticManifold.lean | analyticGroupoid_prod | `analyticGroupoid` is closed under products |
@[deprecated "use instead `IsManifold ω`" (since := "2025-04-13")]
AnalyticManifold (I : ModelWithCorners 𝕜 E H) (M : Type*) [TopologicalSpace M]
[ChartedSpace H M] : Prop extends HasGroupoid M (analyticGroupoid I) | class | Deprecated | [
"Mathlib.Analysis.Analytic.Constructions",
"Mathlib.Geometry.Manifold.IsManifold.Basic"
] | Mathlib/Deprecated/AnalyticManifold.lean | AnalyticManifold | An analytic manifold w.r.t. a model `I : ModelWithCorners 𝕜 E H` is a charted space over `H`
s.t. all extended chart conversion maps are analytic. |
AnalyticManifold.self : AnalyticManifold 𝓘(𝕜, E) E where | instance | Deprecated | [
"Mathlib.Analysis.Analytic.Constructions",
"Mathlib.Geometry.Manifold.IsManifold.Basic"
] | Mathlib/Deprecated/AnalyticManifold.lean | AnalyticManifold.self | Normed spaces are analytic manifolds over themselves. |
AnalyticManifold.prod {E A : Type} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
[TopologicalSpace A] {F B : Type} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
[TopologicalSpace B] {I : ModelWithCorners 𝕜 E A} {J : ModelWithCorners 𝕜 F B}
{M : Type} [TopologicalSpace M] [ChartedSpace A M] [m : AnalyticManifold I M]
{N : Type} [TopologicalSpace N] [ChartedSpace B N] [n : AnalyticManifold J N] :
AnalyticManifold (I.prod J) (M × N) where
compatible := by
intro f g ⟨f1, f2, hf1, hf2, fe⟩ ⟨g1, g2, hg1, hg2, ge⟩
rw [← fe, ← ge, OpenPartialHomeomorph.prod_symm, OpenPartialHomeomorph.prod_trans]
exact analyticGroupoid_prod (m.toHasGroupoid.compatible f2 g2)
(n.toHasGroupoid.compatible hf2 hg2) | instance | Deprecated | [
"Mathlib.Analysis.Analytic.Constructions",
"Mathlib.Geometry.Manifold.IsManifold.Basic"
] | Mathlib/Deprecated/AnalyticManifold.lean | AnalyticManifold.prod | `M × N` is an analytic manifold if `M` and `N` are |
AnalyticManifold.isManifold [ChartedSpace H M]
[cm : AnalyticManifold I M] :
IsManifold I ∞ M where
compatible hf hg := ⟨(cm.compatible hf hg).1.contDiffOn I.uniqueDiffOn_preimage_source,
(cm.compatible hg hf).1.contDiffOn I.uniqueDiffOn_preimage_source⟩ | instance | Deprecated | [
"Mathlib.Analysis.Analytic.Constructions",
"Mathlib.Geometry.Manifold.IsManifold.Basic"
] | Mathlib/Deprecated/AnalyticManifold.lean | AnalyticManifold.isManifold | Analytic manifolds are smooth manifolds. |
EstimatorData (a : Thunk α) (ε : Type*) where
/-- The value of the bound for `a` representation by a term of `ε`. -/
bound : ε → α
/-- Generate an improved lower bound. -/
improve : ε → Option ε | class | Deprecated | [
"Mathlib.Data.Set.Operations",
"Mathlib.Order.Heyting.Basic",
"Mathlib.Order.RelClasses",
"Mathlib.Order.Hom.Basic",
"Mathlib.Lean.Thunk"
] | Mathlib/Deprecated/Estimator.lean | EstimatorData | Given `[EstimatorData a ε]`
* a term `e : ε` can be interpreted via `bound a e : α` as a lower bound for `a`, and
* we can ask for an improved lower bound via `improve a e : Option ε`.
The value `a` in `α` that we are estimating is hidden inside a `Thunk` to avoid evaluation. |
@[deprecated "No replacement: this was only used \
in the implementation of the removed `rw_search` tactic." (since := "2025-09-11")]
Estimator [Preorder α] (a : Thunk α) (ε : Type*) extends EstimatorData a ε where
/-- The calculated bounds are always lower bounds. -/
bound_le e : bound e ≤ a.get
/-- Calling `improve` either gives a strictly better bound,
or a proof that the current bound is exact. -/
improve_spec e : match improve e with
| none => bound e = a.get
| some e' => bound e < bound e'
set_option linter.deprecated false
open EstimatorData Set | class | Deprecated | [
"Mathlib.Data.Set.Operations",
"Mathlib.Order.Heyting.Basic",
"Mathlib.Order.RelClasses",
"Mathlib.Order.Hom.Basic",
"Mathlib.Lean.Thunk"
] | Mathlib/Deprecated/Estimator.lean | Estimator | Given `[Estimator a ε]`
* we have `bound a e ≤ a.get`, and
* `improve a e` returns none iff `bound a e = a.get`,
and otherwise it returns a strictly better bound. |
Estimator.trivial.{u} {α : Type u} (a : α) : Type u := { b : α // b = a } | abbrev | Deprecated | [
"Mathlib.Data.Set.Operations",
"Mathlib.Order.Heyting.Basic",
"Mathlib.Order.RelClasses",
"Mathlib.Order.Hom.Basic",
"Mathlib.Lean.Thunk"
] | Mathlib/Deprecated/Estimator.lean | Estimator.trivial. | A trivial estimator, containing the actual value. |
Estimator.improveUntilAux
(a : Thunk α) (p : α → Bool) [Estimator a ε]
[WellFoundedGT (range (bound a : ε → α))]
(e : ε) (r : Bool) : Except (Option ε) ε :=
if p (bound a e) then
return e
else
match improve a e, improve_spec e with
| none, _ => .error <| if r then none else e
| some e', _ =>
improveUntilAux a p e' true
termination_by (⟨_, mem_range_self e⟩ : range (bound a)) | def | Deprecated | [
"Mathlib.Data.Set.Operations",
"Mathlib.Order.Heyting.Basic",
"Mathlib.Order.RelClasses",
"Mathlib.Order.Hom.Basic",
"Mathlib.Lean.Thunk"
] | Mathlib/Deprecated/Estimator.lean | Estimator.improveUntilAux | Implementation of `Estimator.improveUntil`. |
Estimator.improveUntil (a : Thunk α) (p : α → Bool)
[Estimator a ε] [WellFoundedGT (range (bound a : ε → α))] (e : ε) :
Except (Option ε) ε :=
Estimator.improveUntilAux a p e false
attribute [local instance] WellFoundedGT.toWellFoundedRelation in | def | Deprecated | [
"Mathlib.Data.Set.Operations",
"Mathlib.Order.Heyting.Basic",
"Mathlib.Order.RelClasses",
"Mathlib.Order.Hom.Basic",
"Mathlib.Lean.Thunk"
] | Mathlib/Deprecated/Estimator.lean | Estimator.improveUntil | Improve an estimate until it satisfies a predicate,
or else return the best available estimate, if any improvement was made. |
Estimator.improveUntilAux_spec (a : Thunk α) (p : α → Bool)
[Estimator a ε] [WellFoundedGT (range (bound a : ε → α))] (e : ε) (r : Bool) :
match Estimator.improveUntilAux a p e r with
| .error _ => ¬ p a.get
| .ok e' => p (bound a e') := by
rw [Estimator.improveUntilAux]
by_cases h : p (bound a e)
· simp only [h]; exact h
· simp only [h]
match improve a e, improve_spec e with
| none, eq =>
simp only [Bool.not_eq_true]
rw [eq] at h
exact Bool.bool_eq_false h
| some e', _ =>
exact Estimator.improveUntilAux_spec a p e' true
termination_by (⟨_, mem_range_self e⟩ : range (bound a)) | theorem | Deprecated | [
"Mathlib.Data.Set.Operations",
"Mathlib.Order.Heyting.Basic",
"Mathlib.Order.RelClasses",
"Mathlib.Order.Hom.Basic",
"Mathlib.Lean.Thunk"
] | Mathlib/Deprecated/Estimator.lean | Estimator.improveUntilAux_spec | If `Estimator.improveUntil a p e` returns `some e'`, then `bound a e'` satisfies `p`.
Otherwise, that value `a` must not satisfy `p`. |
Estimator.improveUntil_spec
(a : Thunk α) (p : α → Bool) [Estimator a ε] [WellFoundedGT (range (bound a : ε → α))] (e : ε) :
match Estimator.improveUntil a p e with
| .error _ => ¬ p a.get
| .ok e' => p (bound a e') :=
Estimator.improveUntilAux_spec a p e false | theorem | Deprecated | [
"Mathlib.Data.Set.Operations",
"Mathlib.Order.Heyting.Basic",
"Mathlib.Order.RelClasses",
"Mathlib.Order.Hom.Basic",
"Mathlib.Lean.Thunk"
] | Mathlib/Deprecated/Estimator.lean | Estimator.improveUntil_spec | If `Estimator.improveUntil a p e` returns `some e'`, then `bound a e'` satisfies `p`.
Otherwise, that value `a` must not satisfy `p`. |
Estimator.fst
(p : Thunk (α × β)) (ε : Type*) [Estimator p ε] where
/-- The wrapped bound for a value in `α × β`,
which we will use as a bound for the first component. -/
inner : ε
variable [∀ a : α, WellFoundedGT { x // x ≤ a }] | structure | Deprecated | [
"Mathlib.Data.Set.Operations",
"Mathlib.Order.Heyting.Basic",
"Mathlib.Order.RelClasses",
"Mathlib.Order.Hom.Basic",
"Mathlib.Lean.Thunk"
] | Mathlib/Deprecated/Estimator.lean | Estimator.fst | An estimator for `(a, b)` can be turned into an estimator for `a`,
simply by repeatedly running `improve` until the first factor "improves".
The hypothesis that `>` is well-founded on `{ q // q ≤ (a, b) }` ensures this terminates. |
Estimator.fstInst [DecidableLT α] [∀ (p : α × β), WellFoundedGT { q // q ≤ p }]
(a : Thunk α) (b : Thunk β) (i : Estimator (a.prod b) ε) :
Estimator a (Estimator.fst (a.prod b) ε) where
bound_le e := (Estimator.bound_le e.inner : bound (a.prod b) e.inner ≤ (a.get, b.get)).1
improve_spec e := by
let bd := (bound (a.prod b) e.inner).1
have := Estimator.improveUntil_spec (a.prod b) (fun p => bd < p.1) e.inner
revert this
simp only [EstimatorData.improve, decide_eq_true_eq]
match Estimator.improveUntil (a.prod b) _ _ with
| .error _ =>
simp only
exact fun w =>
eq_of_le_of_not_lt
(Estimator.bound_le e.inner : bound (a.prod b) e.inner ≤ (a.get, b.get)).1 w
| .ok e' => exact fun w => w | def | Deprecated | [
"Mathlib.Data.Set.Operations",
"Mathlib.Order.Heyting.Basic",
"Mathlib.Order.RelClasses",
"Mathlib.Order.Hom.Basic",
"Mathlib.Lean.Thunk"
] | Mathlib/Deprecated/Estimator.lean | Estimator.fstInst | null |
@[deprecated "Use range_eq_singleton_iff and codomain_trivial_iff_range_trivial"
(since := "2025-06-09")]
codomain_trivial_iff_range_eq_singleton_zero : (0 : β) = 1 ↔ Set.range f = {0} :=
f.codomain_trivial_iff_range_trivial.trans
⟨fun h =>
Set.ext fun y => ⟨fun ⟨x, hx⟩ => by simp [← hx, h x], fun hy => ⟨0, by simpa using hy.symm⟩⟩,
fun h x => Set.mem_singleton_iff.mp (h ▸ Set.mem_range_self x)⟩ | theorem | Deprecated | [
"Mathlib.Algebra.Divisibility.Hom",
"Mathlib.Algebra.Ring.Hom.Defs",
"Mathlib.Data.Set.Insert"
] | Mathlib/Deprecated/RingHom.lean | codomain_trivial_iff_range_eq_singleton_zero | `f : α →+* β` has a trivial codomain iff its range is `{0}`. |
@[deprecated map_dvd (since := "2025-06-09")]
protected map_dvd (f : α →+* β) {a b : α} : a ∣ b → f a ∣ f b :=
map_dvd f | theorem | Deprecated | [
"Mathlib.Algebra.Divisibility.Hom",
"Mathlib.Algebra.Ring.Hom.Defs",
"Mathlib.Data.Set.Insert"
] | Mathlib/Deprecated/RingHom.lean | map_dvd | null |
IsInvariant (ϕ : τ → α → α) (s : Set α) : Prop :=
∀ t, MapsTo (ϕ t) s s
variable (ϕ : τ → α → α) (s : Set α) | def | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | IsInvariant | A set `s ⊆ α` is invariant under `ϕ : τ → α → α` if `ϕ t s ⊆ s` for all `t` in `τ`. |
isInvariant_iff_image : IsInvariant ϕ s ↔ ∀ t, ϕ t '' s ⊆ s := by
simp_rw [IsInvariant, mapsTo_iff_image_subset] | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | isInvariant_iff_image | null |
IsForwardInvariant [Preorder τ] [Zero τ] (ϕ : τ → α → α) (s : Set α) : Prop :=
∀ ⦃t⦄, 0 ≤ t → MapsTo (ϕ t) s s
@[deprecated (since := "2025-09-25")] alias IsFwInvariant := IsForwardInvariant | def | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | IsForwardInvariant | A set `s ⊆ α` is forward-invariant under `ϕ : τ → α → α` if `ϕ t s ⊆ s` for all `t ≥ 0`. |
IsInvariant.isForwardInvariant [Preorder τ] [Zero τ] {ϕ : τ → α → α} {s : Set α}
(h : IsInvariant ϕ s) : IsForwardInvariant ϕ s := fun t _ht => h t
@[deprecated (since := "2025-09-25")]
alias IsInvariant.isFwInvariant := IsInvariant.isForwardInvariant | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | IsInvariant.isForwardInvariant | null |
IsForwardInvariant.isInvariant [AddMonoid τ] [PartialOrder τ] [CanonicallyOrderedAdd τ]
{ϕ : τ → α → α} {s : Set α}
(h : IsForwardInvariant ϕ s) : IsInvariant ϕ s := fun t => h (zero_le t)
@[deprecated (since := "2025-09-25")]
alias IsFwInvariant.isInvariant := IsForwardInvariant.isInvariant | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | IsForwardInvariant.isInvariant | If `τ` is a `CanonicallyOrderedAdd` monoid (e.g., `ℕ` or `ℝ≥0`), then the notions
`IsForwardInvariant` and `IsInvariant` are equivalent. |
isForwardInvariant_iff_isInvariant [AddMonoid τ] [PartialOrder τ] [CanonicallyOrderedAdd τ]
{ϕ : τ → α → α} {s : Set α} :
IsForwardInvariant ϕ s ↔ IsInvariant ϕ s :=
⟨IsForwardInvariant.isInvariant, IsInvariant.isForwardInvariant⟩
@[deprecated (since := "2025-09-25")]
alias isFwInvariant_iff_isInvariant := isForwardInvariant_iff_isInvariant | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | isForwardInvariant_iff_isInvariant | If `τ` is a `CanonicallyOrderedAdd` monoid (e.g., `ℕ` or `ℝ≥0`), then the notions
`IsForwardInvariant` and `IsInvariant` are equivalent. |
Flow (τ : Type*) [TopologicalSpace τ] [AddMonoid τ] [ContinuousAdd τ] (α : Type*)
[TopologicalSpace α] where
/-- The map `τ → α → α` underlying a flow of `τ` on `α`. -/
toFun : τ → α → α
cont' : Continuous (uncurry toFun)
map_add' : ∀ t₁ t₂ x, toFun (t₁ + t₂) x = toFun t₁ (toFun t₂ x)
map_zero' : ∀ x, toFun 0 x = x | structure | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | Flow | A flow on a topological space `α` by an additive topological
monoid `τ` is a continuous monoid action of `τ` on `α`. |
@[ext]
ext : ∀ {ϕ₁ ϕ₂ : Flow τ α}, (∀ t x, ϕ₁ t x = ϕ₂ t x) → ϕ₁ = ϕ₂
| ⟨f₁, _, _, _⟩, ⟨f₂, _, _, _⟩, h => by
congr
funext
exact h _ _
@[continuity, fun_prop] | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | ext | null |
protected continuous {β : Type*} [TopologicalSpace β] {t : β → τ} (ht : Continuous t)
{f : β → α} (hf : Continuous f) : Continuous fun x => ϕ (t x) (f x) :=
ϕ.cont'.comp (ht.prodMk hf)
alias _root_.Continuous.flow := Flow.continuous | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | continuous | null |
map_add (t₁ t₂ : τ) (x : α) : ϕ (t₁ + t₂) x = ϕ t₁ (ϕ t₂ x) := ϕ.map_add' _ _ _
@[simp] | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | map_add | null |
map_zero : ϕ 0 = id := funext ϕ.map_zero' | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | map_zero | null |
map_zero_apply (x : α) : ϕ 0 x = x := ϕ.map_zero' x | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | map_zero_apply | null |
fromIter {g : α → α} (h : Continuous g) : Flow ℕ α where
toFun n x := g^[n] x
cont' := continuous_prod_of_discrete_left.mpr (Continuous.iterate h)
map_add' := iterate_add_apply _
map_zero' _x := rfl | def | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | fromIter | Iterations of a continuous function from a topological space `α`
to itself defines a semiflow by `ℕ` on `α`. |
restrict {s : Set α} (h : IsInvariant ϕ s) : Flow τ (↥s) where
toFun t := (h t).restrict _ _ _
cont' := (ϕ.continuous continuous_fst continuous_subtype_val.snd').subtype_mk _
map_add' _ _ _ := Subtype.ext (map_add _ _ _ _)
map_zero' _ := Subtype.ext (map_zero_apply _ _)
@[simp] | def | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | restrict | Restriction of a flow onto an invariant set. |
coe_restrict_apply {s : Set α} (h : IsInvariant ϕ s) (t : τ) (x : s) :
restrict ϕ h t x = ϕ t x := rfl | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | coe_restrict_apply | null |
toAddAction : AddAction τ α where
vadd := ϕ
add_vadd := ϕ.map_add'
zero_vadd := ϕ.map_zero' | def | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | toAddAction | Convert a flow to an additive monoid action. |
restrictAddSubmonoid (S : AddSubmonoid τ) : Flow S α where
toFun t x := ϕ t x
cont' := ϕ.continuous (continuous_subtype_val.comp continuous_fst) continuous_snd
map_add' t₁ t₂ x := ϕ.map_add' t₁ t₂ x
map_zero' := ϕ.map_zero' | def | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | restrictAddSubmonoid | Restrict a flow by `τ` to a flow by an additive submonoid of `τ`. |
restrictAddSubmonoid_apply (S : AddSubmonoid τ) (t : S) (x : α) :
restrictAddSubmonoid ϕ S t x = ϕ t x := rfl | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | restrictAddSubmonoid_apply | null |
orbit (x : α) : Set α := ϕ.toAddAction.orbit _ x | def | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | orbit | The orbit of a point under a flow. |
orbit_eq_range (x : α) : orbit ϕ x = Set.range (fun t => ϕ t x) := rfl | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | orbit_eq_range | null |
mem_orbit_iff {x₁ x₂ : α} : x₂ ∈ orbit ϕ x₁ ↔ ∃ t : τ, ϕ t x₁ = x₂ :=
ϕ.toAddAction.mem_orbit_iff | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | mem_orbit_iff | null |
mem_orbit (x : α) (t : τ) : ϕ t x ∈ orbit ϕ x := ϕ.toAddAction.mem_orbit .. | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | mem_orbit | null |
mem_orbit_self (x : α) : x ∈ orbit ϕ x := ϕ.toAddAction.mem_orbit_self x | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | mem_orbit_self | null |
nonempty_orbit (x : α) : Set.Nonempty (orbit ϕ x) := ϕ.toAddAction.nonempty_orbit x | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | nonempty_orbit | null |
mem_orbit_of_mem_orbit {x₁ x₂ : α} (t : τ) (h : x₂ ∈ orbit ϕ x₁) : ϕ t x₂ ∈ orbit ϕ x₁ :=
ϕ.toAddAction.mem_orbit_of_mem_orbit t h | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | mem_orbit_of_mem_orbit | null |
isInvariant_orbit (x : α) : IsInvariant ϕ (orbit ϕ x) :=
fun t _ => ϕ.toAddAction.mem_orbit_of_mem_orbit t | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | isInvariant_orbit | The orbit of a point under a flow `ϕ` is invariant under `ϕ`. |
orbit_restrict (s : Set α) (hs : IsInvariant ϕ s) (x : s) :
orbit (ϕ.restrict hs) x = Subtype.val ⁻¹' orbit ϕ x :=
Set.ext (fun x => by simp [orbit_eq_range, Subtype.ext_iff])
variable [Preorder τ] [AddLeftMono τ] | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | orbit_restrict | null |
restrictNonneg : Flow (AddSubmonoid.nonneg τ) α := ϕ.restrictAddSubmonoid (.nonneg τ) | def | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | restrictNonneg | Restrict a flow by `τ` to a flow by the additive submonoid of nonnegative elements of `τ`. |
forwardOrbit (x : α) : Set α := orbit ϕ.restrictNonneg x | def | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | forwardOrbit | The forward orbit of a point under a flow. |
forwardOrbit_eq_range_nonneg (x : α) :
forwardOrbit ϕ x = Set.range (fun t : {t : τ // 0 ≤ t} => ϕ t x) := rfl | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | forwardOrbit_eq_range_nonneg | null |
isForwardInvariant_forwardOrbit (x : α) : IsForwardInvariant ϕ (forwardOrbit ϕ x) :=
fun t h => IsInvariant.isForwardInvariant (isInvariant_orbit ϕ.restrictNonneg x) (t := ⟨t, h⟩) h | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | isForwardInvariant_forwardOrbit | The forward orbit of a point under a flow `ϕ` is forward-invariant under `ϕ`. |
forwardOrbit_subset_orbit (x : α) : forwardOrbit ϕ x ⊆ orbit ϕ x :=
ϕ.toAddAction.orbit_addSubmonoid_subset (AddSubmonoid.nonneg τ) x | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | forwardOrbit_subset_orbit | The forward orbit of a point `x` is contained in the orbit of `x`. |
mem_orbit_of_mem_forwardOrbit {x₁ x₂ : α} (h : x₁ ∈ forwardOrbit ϕ x₂) : x₁ ∈ orbit ϕ x₂ :=
ϕ.forwardOrbit_subset_orbit x₂ h | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | mem_orbit_of_mem_forwardOrbit | null |
IsSemiconjugacy (π : α → β) (ϕ : Flow τ α) (ψ : Flow τ β) : Prop where
cont : Continuous π
surj : Function.Surjective π
semiconj : ∀ t, Function.Semiconj π (ϕ t) (ψ t) | structure | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | IsSemiconjugacy | Given flows `ϕ` by `τ` on `α` and `ψ` by `τ` on `β`, a function `π : α → β` is called a
*semiconjugacy* from `ϕ` to `ψ` if `π` is continuous and surjective, and `π ∘ (ϕ t) = (ψ t) ∘ π` for
all `t : τ`. |
IsSemiconjugacy.comp {π : α → β} {ρ : β → γ}
(h₁ : IsSemiconjugacy π ϕ ψ) (h₂ : IsSemiconjugacy ρ ψ χ) : IsSemiconjugacy (ρ ∘ π) ϕ χ :=
⟨h₂.cont.comp h₁.cont, h₂.surj.comp h₁.surj, fun t => (h₂.semiconj t).comp_left (h₁.semiconj t)⟩ | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | IsSemiconjugacy.comp | The composition of semiconjugacies is a semiconjugacy. |
isSemiconjugacy_id_iff_eq (ϕ ψ : Flow τ α) : IsSemiconjugacy id ϕ ψ ↔ ϕ = ψ :=
⟨fun h => ext h.semiconj, fun h => h.recOn ⟨continuous_id, surjective_id, fun _ => .id_left⟩⟩ | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | isSemiconjugacy_id_iff_eq | The identity is a semiconjugacy from `ϕ` to `ψ` if and only if `ϕ` and `ψ` are equal. |
IsFactorOf (ψ : Flow τ β) (ϕ : Flow τ α) : Prop := ∃ π : α → β, IsSemiconjugacy π ϕ ψ | def | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | IsFactorOf | A flow `ψ` is called a *factor* of `ϕ` if there exists a semiconjugacy from `ϕ` to `ψ`. |
IsSemiconjugacy.isFactorOf {π : α → β} (h : IsSemiconjugacy π ϕ ψ) : IsFactorOf ψ ϕ :=
⟨π, h⟩ | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | IsSemiconjugacy.isFactorOf | null |
IsFactorOf.trans (h₁ : IsFactorOf ϕ ψ) (h₂ : IsFactorOf ψ χ) : IsFactorOf ϕ χ :=
h₁.elim fun π hπ => h₂.elim fun ρ hρ => ⟨π ∘ ρ, hρ.comp χ ψ ϕ hπ⟩ | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | IsFactorOf.trans | Transitivity of factors of flows. |
IsFactorOf.self : IsFactorOf ϕ ϕ := ⟨id, (isSemiconjugacy_id_iff_eq ϕ ϕ).mpr (by rfl)⟩ | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | IsFactorOf.self | Every flow is a factor of itself. |
isInvariant_iff_image_eq (s : Set α) : IsInvariant ϕ s ↔ ∀ t, ϕ t '' s = s :=
(isInvariant_iff_image _ _).trans
(Iff.intro
(fun h t => Subset.antisymm (h t) fun _ hx => ⟨_, h (-t) ⟨_, hx, rfl⟩, by simp [← map_add]⟩)
fun h t => by rw [h t]) | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | isInvariant_iff_image_eq | null |
reverse : Flow τ α where
toFun t := ϕ (-t)
cont' := ϕ.continuous continuous_fst.neg continuous_snd
map_add' _ _ _ := by rw [neg_add, map_add]
map_zero' _ := by rw [neg_zero, map_zero_apply]
@[continuity, fun_prop] | def | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | reverse | The time-reversal of a flow `ϕ` by a (commutative, additive) group
is defined `ϕ.reverse t x = ϕ (-t) x`. |
continuous_toFun (t : τ) : Continuous (ϕ.toFun t) := by
fun_prop | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | continuous_toFun | null |
toHomeomorph (t : τ) : (α ≃ₜ α) where
toFun := ϕ t
invFun := ϕ (-t)
left_inv x := by rw [← map_add, neg_add_cancel, map_zero_apply]
right_inv x := by rw [← map_add, add_neg_cancel, map_zero_apply] | def | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | toHomeomorph | The map `ϕ t` as a homeomorphism. |
image_eq_preimage (t : τ) (s : Set α) : ϕ t '' s = ϕ (-t) ⁻¹' s :=
(ϕ.toHomeomorph t).toEquiv.image_eq_preimage s | theorem | Dynamics | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Algebra.Group.Defs",
"Mathlib.Algebra.Order.Monoid.Submonoid"
] | Mathlib/Dynamics/Flow.lean | image_eq_preimage | null |
AddAction.IsMinimal (M α : Type*) [AddMonoid M] [TopologicalSpace α] [AddAction M α] :
Prop where
dense_orbit : ∀ x : α, Dense (AddAction.orbit M x) | class | Dynamics | [
"Mathlib.Topology.Algebra.ConstMulAction"
] | Mathlib/Dynamics/Minimal.lean | AddAction.IsMinimal | An action of an additive monoid `M` on a topological space is called *minimal* if the `M`-orbit
of every point `x : α` is dense. |
@[to_additive]
MulAction.IsMinimal (M α : Type*) [Monoid M] [TopologicalSpace α] [MulAction M α] :
Prop where
dense_orbit : ∀ x : α, Dense (MulAction.orbit M x)
open MulAction Set
variable (M G : Type*) {α : Type*} [Monoid M] [Group G] [TopologicalSpace α] [MulAction M α]
[MulAction G α]
@[to_additive] | class | Dynamics | [
"Mathlib.Topology.Algebra.ConstMulAction"
] | Mathlib/Dynamics/Minimal.lean | MulAction.IsMinimal | An action of a monoid `M` on a topological space is called *minimal* if the `M`-orbit of every
point `x : α` is dense. |
MulAction.dense_orbit [IsMinimal M α] (x : α) : Dense (orbit M x) :=
MulAction.IsMinimal.dense_orbit x
@[to_additive] | theorem | Dynamics | [
"Mathlib.Topology.Algebra.ConstMulAction"
] | Mathlib/Dynamics/Minimal.lean | MulAction.dense_orbit | null |
denseRange_smul [IsMinimal M α] (x : α) : DenseRange fun c : M ↦ c • x :=
MulAction.dense_orbit M x
@[to_additive] | theorem | Dynamics | [
"Mathlib.Topology.Algebra.ConstMulAction"
] | Mathlib/Dynamics/Minimal.lean | denseRange_smul | null |
@[to_additive]
IsOpen.exists_smul_mem [IsMinimal M α] (x : α) {U : Set α} (hUo : IsOpen U)
(hne : U.Nonempty) : ∃ c : M, c • x ∈ U :=
(denseRange_smul M x).exists_mem_open hUo hne
@[to_additive] | theorem | Dynamics | [
"Mathlib.Topology.Algebra.ConstMulAction"
] | Mathlib/Dynamics/Minimal.lean | IsOpen.exists_smul_mem | null |
IsOpen.iUnion_preimage_smul [IsMinimal M α] {U : Set α} (hUo : IsOpen U)
(hne : U.Nonempty) : ⋃ c : M, (c • ·) ⁻¹' U = univ :=
iUnion_eq_univ_iff.2 fun x ↦ hUo.exists_smul_mem M x hne
@[to_additive] | theorem | Dynamics | [
"Mathlib.Topology.Algebra.ConstMulAction"
] | Mathlib/Dynamics/Minimal.lean | IsOpen.iUnion_preimage_smul | null |
IsOpen.iUnion_smul [IsMinimal G α] {U : Set α} (hUo : IsOpen U) (hne : U.Nonempty) :
⋃ g : G, g • U = univ :=
iUnion_eq_univ_iff.2 fun x ↦
let ⟨g, hg⟩ := hUo.exists_smul_mem G x hne
⟨g⁻¹, _, hg, inv_smul_smul _ _⟩
@[to_additive] | theorem | Dynamics | [
"Mathlib.Topology.Algebra.ConstMulAction"
] | Mathlib/Dynamics/Minimal.lean | IsOpen.iUnion_smul | null |
IsCompact.exists_finite_cover_smul [IsMinimal G α] [ContinuousConstSMul G α]
{K U : Set α} (hK : IsCompact K) (hUo : IsOpen U) (hne : U.Nonempty) :
∃ I : Finset G, K ⊆ ⋃ g ∈ I, g • U :=
(hK.elim_finite_subcover (fun g ↦ g • U) fun _ ↦ hUo.smul _) <| calc
K ⊆ univ := subset_univ K
_ = ⋃ g : G, g • U := (hUo.iUnion_smul G hne).symm
@[to_additive] | theorem | Dynamics | [
"Mathlib.Topology.Algebra.ConstMulAction"
] | Mathlib/Dynamics/Minimal.lean | IsCompact.exists_finite_cover_smul | null |
dense_of_nonempty_smul_invariant [IsMinimal M α] {s : Set α} (hne : s.Nonempty)
(hsmul : ∀ c : M, c • s ⊆ s) : Dense s :=
let ⟨x, hx⟩ := hne
(MulAction.dense_orbit M x).mono (range_subset_iff.2 fun c ↦ hsmul c ⟨x, hx, rfl⟩)
@[to_additive] | theorem | Dynamics | [
"Mathlib.Topology.Algebra.ConstMulAction"
] | Mathlib/Dynamics/Minimal.lean | dense_of_nonempty_smul_invariant | null |
eq_empty_or_univ_of_smul_invariant_closed [IsMinimal M α] {s : Set α} (hs : IsClosed s)
(hsmul : ∀ c : M, c • s ⊆ s) : s = ∅ ∨ s = univ :=
s.eq_empty_or_nonempty.imp_right fun hne ↦
hs.closure_eq ▸ (dense_of_nonempty_smul_invariant M hne hsmul).closure_eq
@[to_additive] | theorem | Dynamics | [
"Mathlib.Topology.Algebra.ConstMulAction"
] | Mathlib/Dynamics/Minimal.lean | eq_empty_or_univ_of_smul_invariant_closed | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.