name
stringlengths 3
112
| file
stringlengths 21
116
| statement
stringlengths 17
8.64k
| state
stringlengths 7
205k
| tactic
stringlengths 3
4.55k
| result
stringlengths 7
205k
| id
stringlengths 16
16
|
|---|---|---|---|---|---|---|
Set.star_mem_center
|
Mathlib/Algebra/Star/Center.lean
|
theorem Set.star_mem_center (ha : a ∈ Set.center R) : star a ∈ Set.center R where
comm
|
R : Type u_1
inst✝¹ : Mul R
inst✝ : StarMul R
a : R
ha : a ∈ center R
b c : R
⊢ star a * star (star c * star b) = star (star c * star b * a)
|
rw [← star_mul]
|
no goals
|
c15bad2514aa2cf1
|
Quiver.Push.lift_comp
|
Mathlib/Combinatorics/Quiver/Push.lean
|
theorem lift_comp : (of σ ⋙q lift σ φ τ h) = φ
|
case h_map.h
V : Type u_1
inst✝¹ : Quiver V
W : Type u_2
σ : V → W
W' : Type u_3
inst✝ : Quiver W'
φ : V ⥤q W'
τ : W → W'
h : ∀ (x : V), φ.obj x = τ (σ x)
X Y : V
f : X ⟶ Y
⊢ HEq (⋯.mpr (φ.map f)) (⋯ ▸ ⋯ ▸ φ.map f)
|
apply (cast_heq _ _).trans
|
case h_map.h
V : Type u_1
inst✝¹ : Quiver V
W : Type u_2
σ : V → W
W' : Type u_3
inst✝ : Quiver W'
φ : V ⥤q W'
τ : W → W'
h : ∀ (x : V), φ.obj x = τ (σ x)
X Y : V
f : X ⟶ Y
⊢ HEq (φ.map f) (⋯ ▸ ⋯ ▸ φ.map f)
|
2ad23c8af09b67fc
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.clear_insert_inductive_case
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.lean
|
theorem clear_insert_inductive_case {n : Nat} (f : DefaultFormula n) (f_assignments_size : f.assignments.size = n)
(units : Array (Literal (PosFin n))) (units_nodup : ∀ i : Fin units.size, ∀ j : Fin units.size, i ≠ j → units[i] ≠ units[j])
(idx : Fin units.size) (assignments : Array Assignment)
(ih : ClearInsertInductionMotive f f_assignments_size units idx.1 assignments) :
ClearInsertInductionMotive f f_assignments_size units (idx.1 + 1) (clearUnit assignments units[idx])
|
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
units : Array (Literal (PosFin n))
units_nodup : ∀ (i j : Fin units.size), i ≠ j → units[i] ≠ units[j]
idx : Fin units.size
assignments : Array Assignment
hsize : assignments.size = n
hsize' : (clearUnit assignments units[idx]).size = n
i : Fin n
j1 : Fin units.size
j1_ge_idx : ↑j1 ≥ ↑idx
j2 : Fin units.size
j2_ge_idx : ↑j2 ≥ ↑idx
i_gt_zero : ↑i > 0
ih1 : units[↑j1] = (⟨↑i, ⋯⟩, true)
ih2 : units[↑j2] = (⟨↑i, ⋯⟩, false)
ih3 : assignments[↑i] = both
ih4 : f.assignments[↑i] = unassigned
ih5 : ∀ (k : Fin units.size), ↑k ≥ ↑idx → ¬k = j1 → ¬k = j2 → ¬units[↑k].fst.val = ↑i
idx_ne_j1 : ¬idx = j1
idx_eq_j2 : idx = j2
k : Fin units.size
k_ge_idx_add_one : ↑k ≥ ↑idx + 1
k_ne_j1 : k ≠ j1
h1 : units[k].fst.val = ↑i
h2 : ¬units[↑k].snd = true
⊢ k ≠ idx
|
intro k_eq_idx
|
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
units : Array (Literal (PosFin n))
units_nodup : ∀ (i j : Fin units.size), i ≠ j → units[i] ≠ units[j]
idx : Fin units.size
assignments : Array Assignment
hsize : assignments.size = n
hsize' : (clearUnit assignments units[idx]).size = n
i : Fin n
j1 : Fin units.size
j1_ge_idx : ↑j1 ≥ ↑idx
j2 : Fin units.size
j2_ge_idx : ↑j2 ≥ ↑idx
i_gt_zero : ↑i > 0
ih1 : units[↑j1] = (⟨↑i, ⋯⟩, true)
ih2 : units[↑j2] = (⟨↑i, ⋯⟩, false)
ih3 : assignments[↑i] = both
ih4 : f.assignments[↑i] = unassigned
ih5 : ∀ (k : Fin units.size), ↑k ≥ ↑idx → ¬k = j1 → ¬k = j2 → ¬units[↑k].fst.val = ↑i
idx_ne_j1 : ¬idx = j1
idx_eq_j2 : idx = j2
k : Fin units.size
k_ge_idx_add_one : ↑k ≥ ↑idx + 1
k_ne_j1 : k ≠ j1
h1 : units[k].fst.val = ↑i
h2 : ¬units[↑k].snd = true
k_eq_idx : k = idx
⊢ False
|
c90be518eb885cb1
|
dite_ne_right_iff
|
Mathlib/Logic/Basic.lean
|
theorem dite_ne_right_iff : (dite P A fun _ ↦ b) ≠ b ↔ ∃ h, A h ≠ b
|
α : Sort u_1
P : Prop
inst✝ : Decidable P
b : α
A : P → α
⊢ (dite P A fun x => b) ≠ b ↔ ∃ h, A h ≠ b
|
simp only [Ne, dite_eq_right_iff, not_forall]
|
no goals
|
f3fd6e49415d8434
|
Matroid.IsBasis.isBasis_isRestriction
|
Mathlib/Data/Matroid/Restrict.lean
|
theorem IsBasis.isBasis_isRestriction (hI : M.IsBasis I X) (hNM : N ≤r M) (hX : X ⊆ N.E) :
N.IsBasis I X
|
α : Type u_1
M : Matroid α
I X : Set α
N : Matroid α
hI : M.IsBasis I X
hNM : N ≤r M
hX : X ⊆ N.E
⊢ N.IsBasis I X
|
obtain ⟨R, hR, rfl⟩ := hNM
|
case intro.intro
α : Type u_1
M : Matroid α
I X : Set α
hI : M.IsBasis I X
R : Set α
hR : R ⊆ M.E
hX : X ⊆ (M ↾ R).E
⊢ (M ↾ R).IsBasis I X
|
6c3f3b707679054a
|
BoxIntegral.unitPartition.prepartition_tag
|
Mathlib/Analysis/BoxIntegral/UnitPartition.lean
|
theorem prepartition_tag {ν : ι → ℤ} {B : Box ι} (hν : ν ∈ admissibleIndex n B) :
(prepartition n B).tag (box n ν) = tag n ν
|
ι : Type u_1
n : ℕ
inst✝¹ : NeZero n
inst✝ : Fintype ι
ν : ι → ℤ
B : Box ι
hν : ν ∈ admissibleIndex n B
⊢ (prepartition n B).tag (box n ν) = tag n ν
|
dsimp only [prepartition]
|
ι : Type u_1
n : ℕ
inst✝¹ : NeZero n
inst✝ : Fintype ι
ν : ι → ℤ
B : Box ι
hν : ν ∈ admissibleIndex n B
⊢ (if hI : ∃ ν_1 ∈ admissibleIndex n B, box n ν = box n ν_1 then tag n hI.choose else ⋯.choose) = tag n ν
|
50d6717226e9f93f
|
SimpleGraph.Subgraph.IsMatching.even_card
|
Mathlib/Combinatorics/SimpleGraph/Matching.lean
|
theorem IsMatching.even_card [Fintype M.verts] (h : M.IsMatching) : Even M.verts.toFinset.card
|
V : Type u_1
G : SimpleGraph V
M : G.Subgraph
inst✝ : Fintype ↑M.verts
h : M.IsMatching
⊢ Even M.verts.toFinset.card
|
classical
rw [isMatching_iff_forall_degree] at h
use M.coe.edgeFinset.card
rw [← two_mul, ← M.coe.sum_degrees_eq_twice_card_edges]
convert_to _ = Finset.sum Finset.univ fun v => SimpleGraph.degree (Subgraph.coe M) v using 3
simp [h, Finset.card_univ]
|
no goals
|
c50af873c5d088dd
|
List.perm_dlookup
|
Mathlib/Data/List/Sigma.lean
|
theorem perm_dlookup (a : α) {l₁ l₂ : List (Sigma β)} (nd₁ : l₁.NodupKeys) (nd₂ : l₂.NodupKeys)
(p : l₁ ~ l₂) : dlookup a l₁ = dlookup a l₂
|
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd₁ : l₁.NodupKeys
nd₂ : l₂.NodupKeys
p : l₁ ~ l₂
⊢ dlookup a l₁ = dlookup a l₂
|
ext b
|
case a
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd₁ : l₁.NodupKeys
nd₂ : l₂.NodupKeys
p : l₁ ~ l₂
b : β a
⊢ b ∈ dlookup a l₁ ↔ b ∈ dlookup a l₂
|
0a0c8107a3d4edc7
|
Set.Ioo_union_Ioo'
|
Mathlib/Order/Interval/Set/Basic.lean
|
theorem Ioo_union_Ioo' (h₁ : c < b) (h₂ : a < d) : Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)
|
case pos
α : Type u_1
inst✝ : LinearOrder α
a b c d : α
h₁ : c < b
h₂ : a < d
x : α
hc : ¬c < x
hd : x < d
hxb : x < b
⊢ a < x ∧ x < b ∨ c < x ∧ x < d ↔ (a < x ∨ c < x) ∧ (x < b ∨ x < d)
|
simp only [hxb, and_true, hc, false_and, or_false, true_or]
|
no goals
|
925542e85b57dafe
|
PiNat.mem_cylinder_iff_eq
|
Mathlib/Topology/MetricSpace/PiNat.lean
|
theorem mem_cylinder_iff_eq {x y : ∀ n, E n} {n : ℕ} :
y ∈ cylinder x n ↔ cylinder y n = cylinder x n
|
case mp.h₂
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
hy : y ∈ cylinder x n
z : (n : ℕ) → E n
hz : z ∈ cylinder x n
i : ℕ
hi : i < n
⊢ z i = y i
|
rw [hy i hi]
|
case mp.h₂
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
hy : y ∈ cylinder x n
z : (n : ℕ) → E n
hz : z ∈ cylinder x n
i : ℕ
hi : i < n
⊢ z i = x i
|
1650d6a7263b81d8
|
OreLocalization.smul'_char
|
Mathlib/GroupTheory/OreLocalization/Basic.lean
|
theorem smul'_char (r₁ : R) (r₂ : X) (s₁ s₂ : S) (u : S) (v : R) (huv : u * r₁ = v * s₂) :
OreLocalization.smul' r₁ s₁ r₂ s₂ = v • r₂ /ₒ (u * s₁)
|
R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type u_2
inst✝ : MulAction R X
r₁ : R
r₂ : X
s₁ s₂ u : ↥S
v : R
huv : ↑u * r₁ = v * ↑s₂
⊢ oreNum r₁ s₂ • r₂ /ₒ (oreDenom r₁ s₂ * s₁) = v • r₂ /ₒ (u * s₁)
|
have h₀ := ore_eq r₁ s₂
|
R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type u_2
inst✝ : MulAction R X
r₁ : R
r₂ : X
s₁ s₂ u : ↥S
v : R
huv : ↑u * r₁ = v * ↑s₂
h₀ : ↑(oreDenom r₁ s₂) * r₁ = oreNum r₁ s₂ * ↑s₂
⊢ oreNum r₁ s₂ • r₂ /ₒ (oreDenom r₁ s₂ * s₁) = v • r₂ /ₒ (u * s₁)
|
158523f845373f5e
|
List.max?_le_iff
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/MinMax.lean
|
theorem max?_le_iff [Max α] [LE α]
(max_le_iff : ∀ a b c : α, max b c ≤ a ↔ b ≤ a ∧ c ≤ a) :
{xs : List α} → xs.max? = some a → ∀ {x}, a ≤ x ↔ ∀ b ∈ xs, b ≤ x
| nil => by simp
| cons x xs => by
rw [max?]; rintro ⟨⟩ y
induction xs generalizing x with
| nil => simp
| cons y xs ih => simp [ih, max_le_iff, and_assoc]
|
α : Type u_1
a : α
inst✝¹ : Max α
inst✝ : LE α
max_le_iff : ∀ (a b c : α), max b c ≤ a ↔ b ≤ a ∧ c ≤ a
x : α
xs : List α
⊢ some (foldl max x xs) = some a → ∀ {x_1 : α}, a ≤ x_1 ↔ ∀ (b : α), b ∈ x :: xs → b ≤ x_1
|
rintro ⟨⟩ y
|
case refl
α : Type u_1
inst✝¹ : Max α
inst✝ : LE α
max_le_iff : ∀ (a b c : α), max b c ≤ a ↔ b ≤ a ∧ c ≤ a
x : α
xs : List α
y : α
⊢ foldl max x xs ≤ y ↔ ∀ (b : α), b ∈ x :: xs → b ≤ y
|
a37680aba98f711a
|
Finset.centerMass_empty
|
Mathlib/Analysis/Convex/Combination.lean
|
theorem Finset.centerMass_empty : (∅ : Finset ι).centerMass w z = 0
|
R : Type u_1
E : Type u_3
ι : Type u_5
inst✝² : LinearOrderedField R
inst✝¹ : AddCommGroup E
inst✝ : Module R E
w : ι → R
z : ι → E
⊢ ∅.centerMass w z = 0
|
simp only [centerMass, sum_empty, smul_zero]
|
no goals
|
4677fe032673d938
|
GromovHausdorff.totallyBounded
|
Mathlib/Topology/MetricSpace/GromovHausdorff.lean
|
theorem totallyBounded {t : Set GHSpace} {C : ℝ} {u : ℕ → ℝ} {K : ℕ → ℕ}
(ulim : Tendsto u atTop (𝓝 0)) (hdiam : ∀ p ∈ t, diam (univ : Set (GHSpace.Rep p)) ≤ C)
(hcov : ∀ p ∈ t, ∀ n : ℕ, ∃ s : Set (GHSpace.Rep p),
(#s) ≤ K n ∧ univ ⊆ ⋃ x ∈ s, ball x (u n)) :
TotallyBounded t
|
case intro.refine_2.mk.mk
t : Set GHSpace
C : ℝ
u : ℕ → ℝ
K : ℕ → ℕ
ulim : Tendsto u atTop (𝓝 0)
hdiam : ∀ p ∈ t, diam univ ≤ C
hcov : ∀ p ∈ t, ∀ (n : ℕ), ∃ s, #↑s ≤ ↑(K n) ∧ univ ⊆ ⋃ x ∈ s, ball x (u n)
δ : ℝ
δpos : δ > 0
ε : ℝ := 1 / 5 * δ
εpos : 0 < ε
n : ℕ
hn : ∀ n_1 ≥ n, dist (u n_1) 0 < ε
u_le_ε : u n ≤ ε
s : (p : GHSpace) → Set p.Rep
N : GHSpace → ℕ
hN : ∀ (p : GHSpace), N p ≤ K n
E : (p : GHSpace) → ↑(s p) ≃ Fin (N p)
hs : ∀ p ∈ t, univ ⊆ ⋃ x ∈ s p, ball x (u n)
M : ℕ := ⌊ε⁻¹ * (C ⊔ 0)⌋₊
F : GHSpace → (k : Fin (K n).succ) × (Fin ↑k → Fin ↑k → Fin M.succ) :=
fun p => ⟨⟨N p, ⋯⟩, fun a b => ⟨M ⊓ ⌊ε⁻¹ * dist ((E p).symm a) ((E p).symm b)⌋₊, ⋯⟩⟩
p : GHSpace
pt : p ∈ t
q : GHSpace
qt : q ∈ t
hpq : (fun p => F ↑p) ⟨p, pt⟩ = (fun p => F ↑p) ⟨q, qt⟩
Npq : N p = N q
Ψ : ↑(s p) → ↑(s q) := fun x => (E q).symm (Fin.cast Npq ((E p) x))
⊢ dist ↑⟨p, pt⟩ ↑⟨q, qt⟩ < δ
|
let Φ : s p → q.Rep := fun x => Ψ x
|
case intro.refine_2.mk.mk
t : Set GHSpace
C : ℝ
u : ℕ → ℝ
K : ℕ → ℕ
ulim : Tendsto u atTop (𝓝 0)
hdiam : ∀ p ∈ t, diam univ ≤ C
hcov : ∀ p ∈ t, ∀ (n : ℕ), ∃ s, #↑s ≤ ↑(K n) ∧ univ ⊆ ⋃ x ∈ s, ball x (u n)
δ : ℝ
δpos : δ > 0
ε : ℝ := 1 / 5 * δ
εpos : 0 < ε
n : ℕ
hn : ∀ n_1 ≥ n, dist (u n_1) 0 < ε
u_le_ε : u n ≤ ε
s : (p : GHSpace) → Set p.Rep
N : GHSpace → ℕ
hN : ∀ (p : GHSpace), N p ≤ K n
E : (p : GHSpace) → ↑(s p) ≃ Fin (N p)
hs : ∀ p ∈ t, univ ⊆ ⋃ x ∈ s p, ball x (u n)
M : ℕ := ⌊ε⁻¹ * (C ⊔ 0)⌋₊
F : GHSpace → (k : Fin (K n).succ) × (Fin ↑k → Fin ↑k → Fin M.succ) :=
fun p => ⟨⟨N p, ⋯⟩, fun a b => ⟨M ⊓ ⌊ε⁻¹ * dist ((E p).symm a) ((E p).symm b)⌋₊, ⋯⟩⟩
p : GHSpace
pt : p ∈ t
q : GHSpace
qt : q ∈ t
hpq : (fun p => F ↑p) ⟨p, pt⟩ = (fun p => F ↑p) ⟨q, qt⟩
Npq : N p = N q
Ψ : ↑(s p) → ↑(s q) := fun x => (E q).symm (Fin.cast Npq ((E p) x))
Φ : ↑(s p) → q.Rep := fun x => ↑(Ψ x)
⊢ dist ↑⟨p, pt⟩ ↑⟨q, qt⟩ < δ
|
c10025d34debaff9
|
Matroid.IsBasis.closure_eq_closure
|
Mathlib/Data/Matroid/Closure.lean
|
lemma IsBasis.closure_eq_closure (h : M.IsBasis I X) : M.closure I = M.closure X
|
α : Type u_2
M : Matroid α
X I : Set α
h : M.IsBasis I X
⊢ M.closure X ⊆ M.closure {x | M.IsBasis I (insert x I)}
|
exact M.closure_subset_closure fun e he ↦ (h.isBasis_subset (subset_insert _ _)
(insert_subset he h.subset))
|
no goals
|
7e99c226dd2c4c16
|
ENNReal.div_zero
|
Mathlib/Data/ENNReal/Inv.lean
|
theorem div_zero (h : a ≠ 0) : a / 0 = ∞
|
a : ℝ≥0∞
h : a ≠ 0
⊢ a / 0 = ⊤
|
simp [div_eq_mul_inv, h]
|
no goals
|
6209f8f22d805448
|
MeasureTheory.lintegral_rpow_eq_lintegral_meas_lt_mul
|
Mathlib/Analysis/SpecialFunctions/Pow/Integral.lean
|
theorem lintegral_rpow_eq_lintegral_meas_lt_mul :
∫⁻ ω, ENNReal.ofReal (f ω ^ p) ∂μ =
ENNReal.ofReal p * ∫⁻ t in Ioi 0, μ {a : α | t < f a} * ENNReal.ofReal (t ^ (p - 1))
|
α : Type u_1
inst✝ : MeasurableSpace α
f : α → ℝ
μ : Measure α
f_nn : 0 ≤ᶠ[ae μ] f
f_mble : AEMeasurable f μ
p : ℝ
p_pos : 0 < p
⊢ ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1)) =
ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, μ {a | t < f a} * ENNReal.ofReal (t ^ (p - 1))
|
apply congr_arg fun z => ENNReal.ofReal p * z
|
α : Type u_1
inst✝ : MeasurableSpace α
f : α → ℝ
μ : Measure α
f_nn : 0 ≤ᶠ[ae μ] f
f_mble : AEMeasurable f μ
p : ℝ
p_pos : 0 < p
⊢ ∫⁻ (t : ℝ) in Ioi 0, μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1)) =
∫⁻ (t : ℝ) in Ioi 0, μ {a | t < f a} * ENNReal.ofReal (t ^ (p - 1))
|
a9a2c0230dbc8681
|
Array.fst_unzip
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
|
theorem fst_unzip (as : Array (α × β)) : (Array.unzip as).fst = as.map Prod.fst
|
case mk
α : Type u_1
β : Type u_2
as : List (α × β)
⊢ (foldl (fun x x_1 => (x.fst.push x_1.fst, x.snd.push x_1.snd)) (#[], #[]) { toList := as }).fst =
map Prod.fst { toList := as }
|
simp only [List.foldl_toArray']
|
case mk
α : Type u_1
β : Type u_2
as : List (α × β)
⊢ (List.foldl (fun x x_1 => (x.fst.push x_1.fst, x.snd.push x_1.snd)) (#[], #[]) as).fst = map Prod.fst { toList := as }
|
3740fb34d2c56eb2
|
RootPairing.exists_ge_zero_eq_rootForm
|
Mathlib/LinearAlgebra/RootSystem/Finite/CanonicalBilinear.lean
|
theorem exists_ge_zero_eq_rootForm [Fintype ι] (x : M) (hx : x ∈ span S (range P.root)) :
∃ s ≥ 0, algebraMap S R s = P.RootForm x x
|
ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
inst✝⁸ : AddCommGroup N
inst✝⁷ : Module R N
P : RootPairing ι R M N
S : Type u_5
inst✝⁶ : LinearOrderedCommRing S
inst✝⁵ : Algebra S R
inst✝⁴ : FaithfulSMul S R
inst✝³ : Module S M
inst✝² : IsScalarTower S R M
inst✝¹ : P.IsValuedIn S
inst✝ : Fintype ι
x : M
hx : x ∈ span S (range ⇑P.root)
⊢ ∃ s ≥ 0, (algebraMap S R) s = (P.RootForm x) x
|
refine ⟨(P.posRootForm S).posForm ⟨x, hx⟩ ⟨x, hx⟩, IsSumSq.nonneg ?_, by simp [posRootForm]⟩
|
ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
inst✝⁸ : AddCommGroup N
inst✝⁷ : Module R N
P : RootPairing ι R M N
S : Type u_5
inst✝⁶ : LinearOrderedCommRing S
inst✝⁵ : Algebra S R
inst✝⁴ : FaithfulSMul S R
inst✝³ : Module S M
inst✝² : IsScalarTower S R M
inst✝¹ : P.IsValuedIn S
inst✝ : Fintype ι
x : M
hx : x ∈ span S (range ⇑P.root)
⊢ IsSumSq (((P.posRootForm S).posForm ⟨x, hx⟩) ⟨x, hx⟩)
|
cf1b0b2424f372a7
|
OrderIso.preimage_Ioc
|
Mathlib/Order/Interval/Set/OrderIso.lean
|
theorem preimage_Ioc (e : α ≃o β) (a b : β) : e ⁻¹' Ioc a b = Ioc (e.symm a) (e.symm b)
|
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
a b : β
⊢ ⇑e ⁻¹' Ioc a b = Ioc (e.symm a) (e.symm b)
|
simp [← Ioi_inter_Iic]
|
no goals
|
21a1b5a3fc34c6f4
|
CategoryTheory.Equivalence.funInvIdAssoc_hom_app
|
Mathlib/CategoryTheory/Equivalence.lean
|
theorem funInvIdAssoc_hom_app (e : C ≌ D) (F : C ⥤ E) (X : C) :
(funInvIdAssoc e F).hom.app X = F.map (e.unitInv.app X)
|
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
F : C ⥤ E
X : C
⊢ (e.funInvIdAssoc F).hom.app X = F.map (e.unitInv.app X)
|
dsimp [funInvIdAssoc]
|
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
F : C ⥤ E
X : C
⊢ 𝟙 (F.obj (e.inverse.obj (e.functor.obj X))) ≫ F.map (e.unitIso.inv.app X) ≫ 𝟙 (F.obj X) = F.map (e.unitInv.app X)
|
a493c6cd0239349e
|
DirichletCharacter.differentiable_completedLFunction
|
Mathlib/NumberTheory/LSeries/DirichletContinuation.lean
|
/-- The completed L-function of a non-trivial Dirichlet character is differentiable everywhere. -/
lemma differentiable_completedLFunction {χ : DirichletCharacter ℂ N} (hχ : χ ≠ 1) :
Differentiable ℂ (completedLFunction χ)
|
N : ℕ
inst✝ : NeZero N
χ : DirichletCharacter ℂ N
hχ : χ ≠ 1
⊢ Differentiable ℂ (completedLFunction χ)
|
refine fun s ↦ differentiableAt_completedLFunction _ _ (Or.inr ?_) (Or.inr hχ)
|
N : ℕ
inst✝ : NeZero N
χ : DirichletCharacter ℂ N
hχ : χ ≠ 1
s : ℂ
⊢ N ≠ 1
|
6832c38e9a2c9f2e
|
FirstOrder.Language.BoundedFormula.realize_toFormula
|
Mathlib/ModelTheory/Semantics.lean
|
theorem realize_toFormula (φ : L.BoundedFormula α n) (v : α ⊕ (Fin n) → M) :
φ.toFormula.Realize v ↔ φ.Realize (v ∘ Sum.inl) (v ∘ Sum.inr)
|
case all
L : Language
M : Type w
inst✝ : L.Structure M
α : Type u'
n n✝ : ℕ
f✝ : L.BoundedFormula α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), f✝.toFormula.Realize v ↔ f✝.Realize (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
a : M
h :
f✝.toFormula.Realize (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) ↔ f✝.Realize (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
⊢ (relabel (Sum.elim (Sum.inl ∘ Sum.inl) (Sum.map Sum.inr id ∘ ⇑finSumFinEquiv.symm)) f✝.toFormula).Realize v
(snoc default a) ↔
f✝.Realize (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
|
rw [← h, realize_relabel, Formula.Realize, iff_iff_eq]
|
case all
L : Language
M : Type w
inst✝ : L.Structure M
α : Type u'
n n✝ : ℕ
f✝ : L.BoundedFormula α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), f✝.toFormula.Realize v ↔ f✝.Realize (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
a : M
h :
f✝.toFormula.Realize (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) ↔ f✝.Realize (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)
⊢ Realize f✝.toFormula
(Sum.elim v (snoc default a ∘ castAdd 0) ∘
Sum.elim (Sum.inl ∘ Sum.inl) (Sum.map Sum.inr id ∘ ⇑finSumFinEquiv.symm))
(snoc default a ∘ natAdd 1) =
Realize f✝.toFormula (Sum.elim (v ∘ Sum.inl) (snoc (v ∘ Sum.inr) a)) default
|
9745031cf13e24da
|
Zsqrtd.norm_eq_zero
|
Mathlib/NumberTheory/Zsqrtd/Basic.lean
|
theorem norm_eq_zero {d : ℤ} (h_nonsquare : ∀ n : ℤ, d ≠ n * n) (a : ℤ√d) : norm a = 0 ↔ a = 0
|
d : ℤ
h_nonsquare : ∀ (n : ℤ), d ≠ n * n
a : ℤ√d
ha : a.re * a.re = d * a.im * a.im
h : d < 0
⊢ d * (a.im * a.im) ≤ 0
|
exact mul_nonpos_of_nonpos_of_nonneg h.le (mul_self_nonneg _)
|
no goals
|
1741f43679b93652
|
Std.DHashMap.Internal.List.mem_eraseKey_of_key_beq_eq_false
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/List/Associative.lean
|
theorem mem_eraseKey_of_key_beq_eq_false [BEq α] {a : α}
{l : List ((a : α) × β a)} (p : (a : α) × β a) (hne : (p.1 == a) = false) :
p ∈ eraseKey a l ↔ p ∈ l
|
case isFalse
α : Type u
β : α → Type v
inst✝ : BEq α
a : α
p : (a : α) × β a
hne : (p.fst == a) = false
head✝ : (a : α) × β a
tail✝ : List ((a : α) × β a)
ih : p ∈ eraseKey a tail✝ ↔ p ∈ tail✝
h✝ : ¬(head✝.fst == a) = true
⊢ p ∈ ⟨head✝.fst, head✝.snd⟩ :: eraseKey a tail✝ ↔ p = head✝ ∨ p ∈ tail✝
|
next h =>
simp only [List.mem_cons, ih]
|
no goals
|
997dbbc69c0b9544
|
CompHaus.effectiveEpiFamily_tfae
|
Mathlib/Topology/Category/CompHaus/EffectiveEpi.lean
|
theorem effectiveEpiFamily_tfae
{α : Type} [Finite α] {B : CompHaus.{u}}
(X : α → CompHaus.{u}) (π : (a : α) → (X a ⟶ B)) :
TFAE
[ EffectiveEpiFamily X π
, Epi (Sigma.desc π)
, ∀ b : B, ∃ (a : α) (x : X a), π a x = b
]
|
α : Type
inst✝ : Finite α
B : CompHaus
X : α → CompHaus
π : (a : α) → X a ⟶ B
tfae_2_to_1 : Epi (Sigma.desc π) → EffectiveEpiFamily X π
tfae_1_to_2 : EffectiveEpiFamily X π → Epi (Sigma.desc π)
tfae_3_to_2 : (∀ (b : ↑B.toTop), ∃ a x, (ConcreteCategory.hom (π a)) x = b) → Epi (Sigma.desc π)
x✝ : Epi (Sigma.desc π)
e : Function.Surjective ⇑(ConcreteCategory.hom (Sigma.desc π))
i : ∐ X ≅ finiteCoproduct X :=
(colimit.isColimit (Discrete.functor X)).coconePointUniqueUpToIso (finiteCoproduct.isColimit X)
b : ↑B.toTop
⊢ ∃ a x, (ConcreteCategory.hom (π a)) x = b
|
obtain ⟨t, rfl⟩ := e b
|
case intro
α : Type
inst✝ : Finite α
B : CompHaus
X : α → CompHaus
π : (a : α) → X a ⟶ B
tfae_2_to_1 : Epi (Sigma.desc π) → EffectiveEpiFamily X π
tfae_1_to_2 : EffectiveEpiFamily X π → Epi (Sigma.desc π)
tfae_3_to_2 : (∀ (b : ↑B.toTop), ∃ a x, (ConcreteCategory.hom (π a)) x = b) → Epi (Sigma.desc π)
x✝ : Epi (Sigma.desc π)
e : Function.Surjective ⇑(ConcreteCategory.hom (Sigma.desc π))
i : ∐ X ≅ finiteCoproduct X :=
(colimit.isColimit (Discrete.functor X)).coconePointUniqueUpToIso (finiteCoproduct.isColimit X)
t : ↑(∐ X).toTop
⊢ ∃ a x, (ConcreteCategory.hom (π a)) x = (ConcreteCategory.hom (Sigma.desc π)) t
|
0aeead2cda12faf0
|
exists_associated_pow_of_mul_eq_pow
|
Mathlib/Algebra/GCDMonoid/Basic.lean
|
theorem exists_associated_pow_of_mul_eq_pow [GCDMonoid α] {a b c : α} (hab : IsUnit (gcd a b))
{k : ℕ} (h : a * b = c ^ k) : ∃ d : α, Associated (d ^ k) a
|
case h
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c : α
hab : IsUnit (gcd a b)
k : ℕ
h : a * b = c ^ k
h✝ : Nontrivial α
ha : ¬a = 0
hb : ¬b = 0
hk : k > 0
hc✝ : c ∣ a * b
d₁ d₂ : α
hd₁ : d₁ ∣ a
hd₂ : d₂ ∣ b
hc : c = d₁ * d₂
⊢ Associated (d₁ ^ k) a
|
obtain ⟨h0₁, ⟨a', ha'⟩⟩ := pow_dvd_of_mul_eq_pow ha hab h hc hd₁
|
case h.intro.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c : α
hab : IsUnit (gcd a b)
k : ℕ
h : a * b = c ^ k
h✝ : Nontrivial α
ha : ¬a = 0
hb : ¬b = 0
hk : k > 0
hc✝ : c ∣ a * b
d₁ d₂ : α
hd₁ : d₁ ∣ a
hd₂ : d₂ ∣ b
hc : c = d₁ * d₂
h0₁ : d₁ ^ k ≠ 0
a' : α
ha' : a = d₁ ^ k * a'
⊢ Associated (d₁ ^ k) a
|
4887d5e0abe68a27
|
Polynomial.degree_X_pow
|
Mathlib/Algebra/Polynomial/Degree/Definitions.lean
|
theorem degree_X_pow : degree ((X : R[X]) ^ n) = n
|
R : Type u
inst✝¹ : Semiring R
inst✝ : Nontrivial R
n : ℕ
⊢ (X ^ n).degree = ↑n
|
rw [X_pow_eq_monomial, degree_monomial _ (one_ne_zero' R)]
|
no goals
|
3ebf6c97e2df715a
|
FirstOrder.Language.PartialEquiv.cod_le_cod
|
Mathlib/ModelTheory/PartialEquiv.lean
|
theorem cod_le_cod {f g : M ≃ₚ[L] N} : f ≤ g → f.cod ≤ g.cod
|
case intro
L : Language
M : Type w
N : Type w'
inst✝¹ : L.Structure M
inst✝ : L.Structure N
f g : M ≃ₚ[L] N
w✝ : f.dom ≤ g.dom
eq_fun : g.cod.subtype.comp (g.toEquiv.toEmbedding.comp (inclusion w✝)) = f.cod.subtype.comp f.toEquiv.toEmbedding
n : N
hn : n ∈ f.cod
m : ↥f.dom := f.toEquiv.symm ⟨n, hn⟩
⊢ n ∈ g.cod
|
have : ((subtype _).comp f.toEquiv.toEmbedding) m = n := by simp only [m, Embedding.comp_apply,
Equiv.coe_toEmbedding, Equiv.apply_symm_apply, coe_subtype]
|
case intro
L : Language
M : Type w
N : Type w'
inst✝¹ : L.Structure M
inst✝ : L.Structure N
f g : M ≃ₚ[L] N
w✝ : f.dom ≤ g.dom
eq_fun : g.cod.subtype.comp (g.toEquiv.toEmbedding.comp (inclusion w✝)) = f.cod.subtype.comp f.toEquiv.toEmbedding
n : N
hn : n ∈ f.cod
m : ↥f.dom := f.toEquiv.symm ⟨n, hn⟩
this : (f.cod.subtype.comp f.toEquiv.toEmbedding) m = n
⊢ n ∈ g.cod
|
058229ae64672064
|
PiTensorProduct.mul_comm
|
Mathlib/RingTheory/PiTensorProduct.lean
|
protected lemma mul_comm (x y : ⨂[R] i, A i) : mul x y = mul y x
|
ι : Type u_1
R : Type u_3
A : ι → Type u_4
inst✝² : CommSemiring R
inst✝¹ : (i : ι) → CommSemiring (A i)
inst✝ : (i : ι) → Algebra R (A i)
x y : ⨂[R] (i : ι), A i
⊢ mul = mul.flip
|
ext x y
|
case H.H.H.H
ι : Type u_1
R : Type u_3
A : ι → Type u_4
inst✝² : CommSemiring R
inst✝¹ : (i : ι) → CommSemiring (A i)
inst✝ : (i : ι) → Algebra R (A i)
x✝ y✝ : ⨂[R] (i : ι), A i
x y : (i : ι) → A i
⊢ (((mul.compMultilinearMap (tprod R)) x).compMultilinearMap (tprod R)) y =
(((mul.flip.compMultilinearMap (tprod R)) x).compMultilinearMap (tprod R)) y
|
ad1d587b41a97abc
|
PresentedGroup.generated_by
|
Mathlib/GroupTheory/PresentedGroup.lean
|
theorem generated_by (rels : Set (FreeGroup α)) (H : Subgroup (PresentedGroup rels))
(h : ∀ j : α, PresentedGroup.of j ∈ H) (x : PresentedGroup rels) : x ∈ H
|
case H.Cm
α : Type u_1
rels : Set (FreeGroup α)
H : Subgroup (PresentedGroup rels)
h : ∀ (j : α), of j ∈ H
x✝ y✝ : FreeGroup α
a✝¹ : (mk rels) x✝ ∈ H
a✝ : (mk rels) y✝ ∈ H
⊢ (mk rels) (x✝ * y✝) ∈ H
|
rename_i h1 h2
|
case H.Cm
α : Type u_1
rels : Set (FreeGroup α)
H : Subgroup (PresentedGroup rels)
h : ∀ (j : α), of j ∈ H
x✝ y✝ : FreeGroup α
h1 : (mk rels) x✝ ∈ H
h2 : (mk rels) y✝ ∈ H
⊢ (mk rels) (x✝ * y✝) ∈ H
|
36af71a0cd1686c5
|
AList.lookupFinsupp_support
|
Mathlib/Data/Finsupp/AList.lean
|
theorem lookupFinsupp_support [DecidableEq α] [DecidableEq M] (l : AList fun _x : α => M) :
l.lookupFinsupp.support = (l.1.filter fun x => Sigma.snd x ≠ 0).keys.toFinset
|
α : Type u_1
M : Type u_2
inst✝² : Zero M
inst✝¹ : DecidableEq α
inst✝ : DecidableEq M
l : AList fun _x => M
⊢ (filter (fun x => decide (x.snd ≠ 0)) l.entries).keys.toFinset =
(filter (fun x => decide (x.snd ≠ 0)) l.entries).keys.toFinset
|
congr!
|
no goals
|
f877487f8fda3140
|
ContinuousLinearMap.inner_map_map_iff_adjoint_comp_self
|
Mathlib/Analysis/InnerProductSpace/Adjoint.lean
|
theorem inner_map_map_iff_adjoint_comp_self (u : H →L[𝕜] K) :
(∀ x y : H, ⟪u x, u y⟫_𝕜 = ⟪x, y⟫_𝕜) ↔ adjoint u ∘L u = 1
|
case refine_1
𝕜 : Type u_1
inst✝⁶ : RCLike 𝕜
H : Type u_5
inst✝⁵ : NormedAddCommGroup H
inst✝⁴ : InnerProductSpace 𝕜 H
inst✝³ : CompleteSpace H
K : Type u_6
inst✝² : NormedAddCommGroup K
inst✝¹ : InnerProductSpace 𝕜 K
inst✝ : CompleteSpace K
u : H →L[𝕜] K
h : ∀ (x y : H), ⟪u x, u y⟫_𝕜 = ⟪x, y⟫_𝕜
x : H
⊢ ((adjoint u).comp u) x = 1 x
|
refine ext_inner_right 𝕜 fun y ↦ ?_
|
case refine_1
𝕜 : Type u_1
inst✝⁶ : RCLike 𝕜
H : Type u_5
inst✝⁵ : NormedAddCommGroup H
inst✝⁴ : InnerProductSpace 𝕜 H
inst✝³ : CompleteSpace H
K : Type u_6
inst✝² : NormedAddCommGroup K
inst✝¹ : InnerProductSpace 𝕜 K
inst✝ : CompleteSpace K
u : H →L[𝕜] K
h : ∀ (x y : H), ⟪u x, u y⟫_𝕜 = ⟪x, y⟫_𝕜
x y : H
⊢ ⟪((adjoint u).comp u) x, y⟫_𝕜 = ⟪1 x, y⟫_𝕜
|
76c8f2fe76b6a005
|
ValuationRing.le_total
|
Mathlib/RingTheory/Valuation/ValuationRing.lean
|
theorem le_total (a b : ValueGroup A K) : a ≤ b ∨ b ≤ a
|
case mk.mk.intro.intro.intro.intro.intro.intro.intro.inl.h
A : Type u
inst✝⁵ : CommRing A
K : Type v
inst✝⁴ : Field K
inst✝³ : Algebra A K
inst✝² : IsDomain A
inst✝¹ : ValuationRing A
inst✝ : IsFractionRing A K
a b : ValueGroup A K
xa ya : A
hya : ya ∈ nonZeroDivisors A
xb yb : A
hyb : yb ∈ nonZeroDivisors A
this✝ : (algebraMap A K) ya ≠ 0
this : (algebraMap A K) yb ≠ 0
c : A
h : xa * yb * c = xb * ya
⊢ Quot.mk (⇑(MulAction.orbitRel Aˣ K)) ((algebraMap A K) xb / (algebraMap A K) yb) ≤
Quot.mk (⇑(MulAction.orbitRel Aˣ K)) ((algebraMap A K) xa / (algebraMap A K) ya)
|
use c
|
case h
A : Type u
inst✝⁵ : CommRing A
K : Type v
inst✝⁴ : Field K
inst✝³ : Algebra A K
inst✝² : IsDomain A
inst✝¹ : ValuationRing A
inst✝ : IsFractionRing A K
a b : ValueGroup A K
xa ya : A
hya : ya ∈ nonZeroDivisors A
xb yb : A
hyb : yb ∈ nonZeroDivisors A
this✝ : (algebraMap A K) ya ≠ 0
this : (algebraMap A K) yb ≠ 0
c : A
h : xa * yb * c = xb * ya
⊢ c • ((algebraMap A K) xa / (algebraMap A K) ya) = (algebraMap A K) xb / (algebraMap A K) yb
|
43f1ff2b88bd99b5
|
IncidenceAlgebra.mu_toDual
|
Mathlib/Combinatorics/Enumerative/IncidenceAlgebra.lean
|
@[simp]
lemma mu_toDual (a b : α) : mu 𝕜 (toDual a) (toDual b) = mu 𝕜 b a
|
𝕜 : Type u_2
α : Type u_5
inst✝³ : Ring 𝕜
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
a b : α
this✝ : DecidableRel fun x1 x2 => x1 ≤ x2 := Classical.decRel fun x1 x2 => x1 ≤ x2
mud : IncidenceAlgebra 𝕜 αᵒᵈ := { toFun := fun a b => (mu 𝕜) (ofDual b) (ofDual a), eq_zero_of_not_le' := ⋯ }
this : mud * zeta 𝕜 * mu 𝕜 = mu 𝕜 * zeta 𝕜 * mu 𝕜
⊢ mu 𝕜 = mud
|
symm
|
𝕜 : Type u_2
α : Type u_5
inst✝³ : Ring 𝕜
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
a b : α
this✝ : DecidableRel fun x1 x2 => x1 ≤ x2 := Classical.decRel fun x1 x2 => x1 ≤ x2
mud : IncidenceAlgebra 𝕜 αᵒᵈ := { toFun := fun a b => (mu 𝕜) (ofDual b) (ofDual a), eq_zero_of_not_le' := ⋯ }
this : mud * zeta 𝕜 * mu 𝕜 = mu 𝕜 * zeta 𝕜 * mu 𝕜
⊢ mud = mu 𝕜
|
95f4eed14862eb7a
|
Submodule.mem_sSup_iff_exists_finset
|
Mathlib/LinearAlgebra/Finsupp/Span.lean
|
theorem Submodule.mem_sSup_iff_exists_finset {S : Set (Submodule R M)} {m : M} :
m ∈ sSup S ↔ ∃ s : Finset (Submodule R M), ↑s ⊆ S ∧ m ∈ ⨆ i ∈ s, i
|
case h.e'_3.h.e'_4.h.pq.a.a
R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
S : Set (Submodule R M)
m : M
x✝¹ : ∃ s, ↑s ⊆ S ∧ m ∈ ⨆ i ∈ s, i
s : Finset (Submodule R M)
hsS : ↑s ⊆ S
hs : m ∈ ⨆ i ∈ s, i
x✝ : Submodule R M
⊢ x✝ ∈ s ↔ x✝ ∈ S ∧ x✝ ∈ s
|
aesop
|
no goals
|
4a53431e2aac6cd1
|
ContDiffWithinAt.contDiffOn'
|
Mathlib/Analysis/Calculus/ContDiff/Defs.lean
|
theorem ContDiffWithinAt.contDiffOn' (hm : m ≤ n) (h' : m = ∞ → n = ω)
(h : ContDiffWithinAt 𝕜 n f s x) :
∃ u, IsOpen u ∧ x ∈ u ∧ ContDiffOn 𝕜 m f (insert x s ∩ u)
|
case inl.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type uE
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type uF
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
s : Set E
f : E → F
x : E
m : WithTop ℕ∞
hm : m ≤ ω
h' : m = ∞ → ω = ω
t : Set E
ht : t ∈ 𝓝[insert x s] x
p : E → FormalMultilinearSeries 𝕜 E F
hp : HasFTaylorSeriesUpToOn ω f p t
h'p : ∀ (i : ℕ), AnalyticOn 𝕜 (fun x => p x i) t
u : Set E
huo : IsOpen u
hxu : x ∈ u
hut : u ∩ insert x s ⊆ t
⊢ ∃ u, IsOpen u ∧ x ∈ u ∧ ContDiffOn 𝕜 m f (insert x s ∩ u)
|
rw [inter_comm] at hut
|
case inl.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type uE
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type uF
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
s : Set E
f : E → F
x : E
m : WithTop ℕ∞
hm : m ≤ ω
h' : m = ∞ → ω = ω
t : Set E
ht : t ∈ 𝓝[insert x s] x
p : E → FormalMultilinearSeries 𝕜 E F
hp : HasFTaylorSeriesUpToOn ω f p t
h'p : ∀ (i : ℕ), AnalyticOn 𝕜 (fun x => p x i) t
u : Set E
huo : IsOpen u
hxu : x ∈ u
hut : insert x s ∩ u ⊆ t
⊢ ∃ u, IsOpen u ∧ x ∈ u ∧ ContDiffOn 𝕜 m f (insert x s ∩ u)
|
252a1c681d4d0950
|
Ring.choose_eq_nat_choose
|
Mathlib/RingTheory/Binomial.lean
|
theorem choose_eq_nat_choose [NatPowAssoc R] (n k : ℕ) : choose (n : R) k = Nat.choose n k
|
case zero
R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
k : ℕ
⊢ choose (↑0) k = ↑(Nat.choose 0 k)
|
cases k with
| zero => rw [choose_zero_right, Nat.choose_zero_right, Nat.cast_one]
| succ k => rw [Nat.cast_zero, choose_zero_succ, Nat.choose_zero_succ, Nat.cast_zero]
|
no goals
|
1e26b94f806077b3
|
hasFDerivAt_exp_of_mem_ball
|
Mathlib/Analysis/SpecialFunctions/Exponential.lean
|
theorem hasFDerivAt_exp_of_mem_ball [CharZero 𝕂] {x : 𝔸}
(hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) :
HasFDerivAt (exp 𝕂) (exp 𝕂 x • (1 : 𝔸 →L[𝕂] 𝔸)) x
|
𝕂 : Type u_1
𝔸 : Type u_2
inst✝⁴ : NontriviallyNormedField 𝕂
inst✝³ : NormedCommRing 𝔸
inst✝² : NormedAlgebra 𝕂 𝔸
inst✝¹ : CompleteSpace 𝔸
inst✝ : CharZero 𝕂
x : 𝔸
hx : x ∈ EMetric.ball 0 (expSeries 𝕂 𝔸).radius
hpos : 0 < (expSeries 𝕂 𝔸).radius
⊢ (fun h => exp 𝕂 x * (exp 𝕂 (0 + h) - exp 𝕂 0 - (ContinuousLinearMap.id 𝕂 𝔸) h)) =ᶠ[𝓝 0] fun h =>
exp 𝕂 (x + h) - exp 𝕂 x - exp 𝕂 x • (ContinuousLinearMap.id 𝕂 𝔸) h
|
have : ∀ᶠ h in 𝓝 (0 : 𝔸), h ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius :=
EMetric.ball_mem_nhds _ hpos
|
𝕂 : Type u_1
𝔸 : Type u_2
inst✝⁴ : NontriviallyNormedField 𝕂
inst✝³ : NormedCommRing 𝔸
inst✝² : NormedAlgebra 𝕂 𝔸
inst✝¹ : CompleteSpace 𝔸
inst✝ : CharZero 𝕂
x : 𝔸
hx : x ∈ EMetric.ball 0 (expSeries 𝕂 𝔸).radius
hpos : 0 < (expSeries 𝕂 𝔸).radius
this : ∀ᶠ (h : 𝔸) in 𝓝 0, h ∈ EMetric.ball 0 (expSeries 𝕂 𝔸).radius
⊢ (fun h => exp 𝕂 x * (exp 𝕂 (0 + h) - exp 𝕂 0 - (ContinuousLinearMap.id 𝕂 𝔸) h)) =ᶠ[𝓝 0] fun h =>
exp 𝕂 (x + h) - exp 𝕂 x - exp 𝕂 x • (ContinuousLinearMap.id 𝕂 𝔸) h
|
b912975acf3383c5
|
Filter.HasBasis.liminf_eq_ite
|
Mathlib/Order/LiminfLimsup.lean
|
theorem HasBasis.liminf_eq_ite {v : Filter ι} {p : ι' → Prop} {s : ι' → Set ι}
[Countable (Subtype p)] [Nonempty (Subtype p)] (hv : v.HasBasis p s) (f : ι → α) :
liminf f v = if ∃ (j : Subtype p), s j = ∅ then sSup univ else
if ∀ (j : Subtype p), ¬BddBelow (range (fun (i : s j) ↦ f i)) then sSup ∅
else ⨆ (j : Subtype p), ⨅ (i : s (liminf_reparam f s p j)), f i
|
case neg.H
α : Type u_1
ι : Type u_4
ι' : Type u_5
inst✝² : ConditionallyCompleteLinearOrder α
v : Filter ι
p : ι' → Prop
s : ι' → Set ι
inst✝¹ : Countable (Subtype p)
inst✝ : Nonempty (Subtype p)
hv : v.HasBasis p s
f : ι → α
H : ¬∃ j, s ↑j = ∅
H' : ¬∀ (j : Subtype p), ¬BddBelow (range fun i => f ↑i)
⊢ ∃ j, BddBelow (range fun i => f ↑i)
|
push_neg at H'
|
case neg.H
α : Type u_1
ι : Type u_4
ι' : Type u_5
inst✝² : ConditionallyCompleteLinearOrder α
v : Filter ι
p : ι' → Prop
s : ι' → Set ι
inst✝¹ : Countable (Subtype p)
inst✝ : Nonempty (Subtype p)
hv : v.HasBasis p s
f : ι → α
H : ¬∃ j, s ↑j = ∅
H' : ∃ j, BddBelow (range fun i => f ↑i)
⊢ ∃ j, BddBelow (range fun i => f ↑i)
|
f25bd96869eaf9b2
|
MeasureTheory.Measure.map_linearMap_addHaar_eq_smul_addHaar
|
Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
|
theorem map_linearMap_addHaar_eq_smul_addHaar {f : E →ₗ[ℝ] E} (hf : LinearMap.det f ≠ 0) :
Measure.map f μ = ENNReal.ofReal |(LinearMap.det f)⁻¹| • μ
|
case h
E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : MeasurableSpace E
inst✝² : BorelSpace E
inst✝¹ : FiniteDimensional ℝ E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
f : E →ₗ[ℝ] E
ι : Type := Fin (finrank ℝ E)
this✝¹ : FiniteDimensional ℝ (ι → ℝ)
this✝ : finrank ℝ E = finrank ℝ (ι → ℝ)
e : E ≃ₗ[ℝ] ι → ℝ
g : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : LinearMap.det g ≠ 0
hg : g = ↑e ∘ₗ f ∘ₗ ↑e.symm
gdet : LinearMap.det g = LinearMap.det f
fg : f = ↑e.symm ∘ₗ g ∘ₗ ↑e
Ce : Continuous ⇑e
Cg : Continuous ⇑g
Cesymm : Continuous ⇑e.symm
this : (map (⇑e) μ).IsAddHaarMeasure
x : E
⊢ (⇑e.symm ∘ ⇑e) x = id x
|
simp only [id, Function.comp_apply, LinearEquiv.symm_apply_apply]
|
no goals
|
99679000a5dbc25a
|
List.last_eq_of_concat_eq
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
|
theorem last_eq_of_concat_eq {a b : α} {l₁ l₂ : List α} : concat l₁ a = concat l₂ b → a = b
|
α : Type u_1
a b : α
l₁ l₂ : List α
⊢ l₁.concat a = l₂.concat b → a = b
|
simp only [concat_eq_append]
|
α : Type u_1
a b : α
l₁ l₂ : List α
⊢ l₁ ++ [a] = l₂ ++ [b] → a = b
|
478662c2630897dd
|
Nat.max_sq_add_min_le_pair
|
Mathlib/Data/Nat/Pairing.lean
|
theorem max_sq_add_min_le_pair (m n : ℕ) : max m n ^ 2 + min m n ≤ pair m n
|
case inl
m n : ℕ
h : m < n
⊢ (m ⊔ n) ^ 2 + m ⊓ n ≤ if m < n then n * n + m else m * m + m + n
|
rw [if_pos h, max_eq_right h.le, min_eq_left h.le, Nat.pow_two]
|
no goals
|
bf37f67bbb78318d
|
IsIntegrallyClosed.eq_map_mul_C_of_dvd
|
Mathlib/RingTheory/Polynomial/GaussLemma.lean
|
theorem IsIntegrallyClosed.eq_map_mul_C_of_dvd [IsIntegrallyClosed R] {f : R[X]} (hf : f.Monic)
{g : K[X]} (hg : g ∣ f.map (algebraMap R K)) :
∃ g' : R[X], g'.map (algebraMap R K) * (C <| leadingCoeff g) = g
|
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsIntegrallyClosed R
f : R[X]
hf : f.Monic
g : K[X]
hg : g ∣ map (algebraMap R K) f
g_ne_0 : g ≠ 0
g_mul_dvd : g * C g.leadingCoeff⁻¹ ∣ map (algebraMap R K) f
algeq : ↥(integralClosure R K) ≃ₐ[R] R := ((integralClosure R K).equivOfEq ⊥ ⋯).trans (Algebra.botEquivOfInjective ⋯)
this : (algebraMap R K).comp (↑algeq).toRingHom = (integralClosure R K).toSubring.subtype
⊢ ∃ g', map (algebraMap R K) g' = g * C g.leadingCoeff⁻¹
|
have H :=
(mem_lifts _).1
(integralClosure.mem_lifts_of_monic_of_dvd_map K hf (monic_mul_leadingCoeff_inv g_ne_0)
g_mul_dvd)
|
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsIntegrallyClosed R
f : R[X]
hf : f.Monic
g : K[X]
hg : g ∣ map (algebraMap R K) f
g_ne_0 : g ≠ 0
g_mul_dvd : g * C g.leadingCoeff⁻¹ ∣ map (algebraMap R K) f
algeq : ↥(integralClosure R K) ≃ₐ[R] R := ((integralClosure R K).equivOfEq ⊥ ⋯).trans (Algebra.botEquivOfInjective ⋯)
this : (algebraMap R K).comp (↑algeq).toRingHom = (integralClosure R K).toSubring.subtype
H : ∃ q, map (algebraMap (↥(integralClosure R K)) K) q = g * C g.leadingCoeff⁻¹
⊢ ∃ g', map (algebraMap R K) g' = g * C g.leadingCoeff⁻¹
|
918c3567824cf666
|
MeasureTheory.JordanDecomposition.toSignedMeasure_injective
|
Mathlib/MeasureTheory/Decomposition/Jordan.lean
|
theorem toSignedMeasure_injective : Injective <| @JordanDecomposition.toSignedMeasure α _
|
α : Type u_1
inst✝ : MeasurableSpace α
j₁ j₂ : JordanDecomposition α
hj : j₁.toSignedMeasure = j₂.toSignedMeasure
S : Set α
hS₁ : MeasurableSet S
hS₂ : j₁.toSignedMeasure ≤[S] 0
hS₃ : 0 ≤[Sᶜ] j₁.toSignedMeasure
hS₄ : j₁.posPart S = 0
hS₅ : j₁.negPart Sᶜ = 0
T : Set α
hT₁ : MeasurableSet T
hT₂ : j₁.toSignedMeasure ≤[T] 0
hT₃ : 0 ≤[Tᶜ] j₁.toSignedMeasure
hT₄ : j₂.posPart T = 0
hT₅ : j₂.negPart Tᶜ = 0
hST₁ : ↑j₁.toSignedMeasure (symmDiff Sᶜ Tᶜ) = 0
i : Set α
hi : MeasurableSet i
hμ₁ : (j₁.posPart i).toReal = ↑j₁.toSignedMeasure (i ∩ Sᶜ)
⊢ (j₂.posPart (i ∩ T ∪ i ∩ Tᶜ)).toReal = (j₂.posPart (i ∩ Tᶜ)).toReal
|
rw [measure_union,
show j₂.posPart (i ∩ T) = 0 from
nonpos_iff_eq_zero.1 (hT₄ ▸ measure_mono Set.inter_subset_right),
zero_add]
|
case hd
α : Type u_1
inst✝ : MeasurableSpace α
j₁ j₂ : JordanDecomposition α
hj : j₁.toSignedMeasure = j₂.toSignedMeasure
S : Set α
hS₁ : MeasurableSet S
hS₂ : j₁.toSignedMeasure ≤[S] 0
hS₃ : 0 ≤[Sᶜ] j₁.toSignedMeasure
hS₄ : j₁.posPart S = 0
hS₅ : j₁.negPart Sᶜ = 0
T : Set α
hT₁ : MeasurableSet T
hT₂ : j₁.toSignedMeasure ≤[T] 0
hT₃ : 0 ≤[Tᶜ] j₁.toSignedMeasure
hT₄ : j₂.posPart T = 0
hT₅ : j₂.negPart Tᶜ = 0
hST₁ : ↑j₁.toSignedMeasure (symmDiff Sᶜ Tᶜ) = 0
i : Set α
hi : MeasurableSet i
hμ₁ : (j₁.posPart i).toReal = ↑j₁.toSignedMeasure (i ∩ Sᶜ)
⊢ Disjoint (i ∩ T) (i ∩ Tᶜ)
case h
α : Type u_1
inst✝ : MeasurableSpace α
j₁ j₂ : JordanDecomposition α
hj : j₁.toSignedMeasure = j₂.toSignedMeasure
S : Set α
hS₁ : MeasurableSet S
hS₂ : j₁.toSignedMeasure ≤[S] 0
hS₃ : 0 ≤[Sᶜ] j₁.toSignedMeasure
hS₄ : j₁.posPart S = 0
hS₅ : j₁.negPart Sᶜ = 0
T : Set α
hT₁ : MeasurableSet T
hT₂ : j₁.toSignedMeasure ≤[T] 0
hT₃ : 0 ≤[Tᶜ] j₁.toSignedMeasure
hT₄ : j₂.posPart T = 0
hT₅ : j₂.negPart Tᶜ = 0
hST₁ : ↑j₁.toSignedMeasure (symmDiff Sᶜ Tᶜ) = 0
i : Set α
hi : MeasurableSet i
hμ₁ : (j₁.posPart i).toReal = ↑j₁.toSignedMeasure (i ∩ Sᶜ)
⊢ MeasurableSet (i ∩ Tᶜ)
|
dcb73e0ca837cd73
|
cfcₙHom_comp
|
Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
|
theorem cfcₙHom_comp [UniqueHom R A] (f : C(σₙ R a, R)₀)
(f' : C(σₙ R a, σₙ R (cfcₙHom ha f))₀)
(hff' : ∀ x, f x = f' x) (g : C(σₙ R (cfcₙHom ha f), R)₀) :
cfcₙHom ha (g.comp f') = cfcₙHom (cfcₙHom_predicate ha f) g
|
case refine_2
R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹² : CommSemiring R
inst✝¹¹ : Nontrivial R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : IsTopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : NonUnitalRing A
inst✝⁵ : StarRing A
inst✝⁴ : TopologicalSpace A
inst✝³ : Module R A
inst✝² : IsScalarTower R A A
inst✝¹ : SMulCommClass R A A
instCFCₙ : NonUnitalContinuousFunctionalCalculus R p
a : A
ha : p a
inst✝ : UniqueHom R A
f : C(↑(σₙ R a), R)₀
f' : C(↑(σₙ R a), ↑(σₙ R ((cfcₙHom ha) f)))₀
hff' : ∀ (x : ↑(σₙ R a)), f x = ↑(f' x)
g : C(↑(σₙ R ((cfcₙHom ha) f)), R)₀
ψ : C(↑(σₙ R ((cfcₙHom ha) f)), R)₀ →⋆ₙₐ[R] C(↑(σₙ R a), R)₀ :=
{ toFun := fun x => x.comp f', map_smul' := ⋯, map_zero' := ⋯, map_add' := ⋯, map_mul' := ⋯, map_star' := ⋯ }
φ : C(↑(σₙ R ((cfcₙHom ha) f)), R)₀ →⋆ₙₐ[R] A := (cfcₙHom ha).comp ψ
⊢ φ { toContinuousMap := ContinuousMap.restrict (σₙ R ((cfcₙHom ha) f)) (ContinuousMap.id R), map_zero' := ⋯ } =
(cfcₙHom ha) f
|
simp only [φ, ψ, NonUnitalStarAlgHom.comp_apply, NonUnitalStarAlgHom.coe_mk',
NonUnitalAlgHom.coe_mk]
|
case refine_2
R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹² : CommSemiring R
inst✝¹¹ : Nontrivial R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : IsTopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : NonUnitalRing A
inst✝⁵ : StarRing A
inst✝⁴ : TopologicalSpace A
inst✝³ : Module R A
inst✝² : IsScalarTower R A A
inst✝¹ : SMulCommClass R A A
instCFCₙ : NonUnitalContinuousFunctionalCalculus R p
a : A
ha : p a
inst✝ : UniqueHom R A
f : C(↑(σₙ R a), R)₀
f' : C(↑(σₙ R a), ↑(σₙ R ((cfcₙHom ha) f)))₀
hff' : ∀ (x : ↑(σₙ R a)), f x = ↑(f' x)
g : C(↑(σₙ R ((cfcₙHom ha) f)), R)₀
ψ : C(↑(σₙ R ((cfcₙHom ha) f)), R)₀ →⋆ₙₐ[R] C(↑(σₙ R a), R)₀ :=
{ toFun := fun x => x.comp f', map_smul' := ⋯, map_zero' := ⋯, map_add' := ⋯, map_mul' := ⋯, map_star' := ⋯ }
φ : C(↑(σₙ R ((cfcₙHom ha) f)), R)₀ →⋆ₙₐ[R] A := (cfcₙHom ha).comp ψ
⊢ (cfcₙHom ha)
({ toContinuousMap := ContinuousMap.restrict (σₙ R ((cfcₙHom ha) f)) (ContinuousMap.id R), map_zero' := ⋯ }.comp
f') =
(cfcₙHom ha) f
|
5eff7aa8f4f5d67a
|
TopCat.GlueData.rel_equiv
|
Mathlib/Topology/Gluing.lean
|
theorem rel_equiv : Equivalence D.Rel :=
⟨fun x => ⟨inv (D.f _ _) x.2, IsIso.inv_hom_id_apply (D.f x.fst x.fst) _,
-- Use `elementwise_of%` elaborator instead of `IsIso.inv_hom_id_apply` to work around
-- `ConcreteCategory`/`HasForget` mismatch:
by simp [elementwise_of% IsIso.inv_hom_id (D.f x.fst x.fst)]⟩, by
rintro a b ⟨x, e₁, e₂⟩
exact ⟨D.t _ _ x, e₂, by rw [← e₁, D.t_inv_apply]⟩, by
rintro ⟨i, a⟩ ⟨j, b⟩ ⟨k, c⟩ ⟨x, e₁, e₂⟩
rintro ⟨y, e₃, e₄⟩
let z := (pullbackIsoProdSubtype (D.f j i) (D.f j k)).inv ⟨⟨_, _⟩, e₂.trans e₃.symm⟩
have eq₁ : (D.t j i) ((pullback.fst _ _ : _ /-(D.f j k)-/ ⟶ D.V (j, i)) z) = x
|
case mk.mk.mk.intro.intro.intro.intro
D : GlueData
i : D.J
a : ↑(D.U i)
j : D.J
b : ↑(D.U j)
k : D.J
c : ↑(D.U k)
x : ↑(D.V (⟨i, a⟩.fst, ⟨j, b⟩.fst))
e₁ : (ConcreteCategory.hom (D.f ⟨i, a⟩.fst ⟨j, b⟩.fst)) x = ⟨i, a⟩.snd
e₂ :
(ConcreteCategory.hom (D.f ⟨j, b⟩.fst ⟨i, a⟩.fst)) ((ConcreteCategory.hom (D.t ⟨i, a⟩.fst ⟨j, b⟩.fst)) x) = ⟨j, b⟩.snd
y : ↑(D.V (⟨j, b⟩.fst, ⟨k, c⟩.fst))
e₃ : (ConcreteCategory.hom (D.f ⟨j, b⟩.fst ⟨k, c⟩.fst)) y = ⟨j, b⟩.snd
e₄ :
(ConcreteCategory.hom (D.f ⟨k, c⟩.fst ⟨j, b⟩.fst)) ((ConcreteCategory.hom (D.t ⟨j, b⟩.fst ⟨k, c⟩.fst)) y) = ⟨k, c⟩.snd
⊢ D.Rel ⟨i, a⟩ ⟨k, c⟩
|
let z := (pullbackIsoProdSubtype (D.f j i) (D.f j k)).inv ⟨⟨_, _⟩, e₂.trans e₃.symm⟩
|
case mk.mk.mk.intro.intro.intro.intro
D : GlueData
i : D.J
a : ↑(D.U i)
j : D.J
b : ↑(D.U j)
k : D.J
c : ↑(D.U k)
x : ↑(D.V (⟨i, a⟩.fst, ⟨j, b⟩.fst))
e₁ : (ConcreteCategory.hom (D.f ⟨i, a⟩.fst ⟨j, b⟩.fst)) x = ⟨i, a⟩.snd
e₂ :
(ConcreteCategory.hom (D.f ⟨j, b⟩.fst ⟨i, a⟩.fst)) ((ConcreteCategory.hom (D.t ⟨i, a⟩.fst ⟨j, b⟩.fst)) x) = ⟨j, b⟩.snd
y : ↑(D.V (⟨j, b⟩.fst, ⟨k, c⟩.fst))
e₃ : (ConcreteCategory.hom (D.f ⟨j, b⟩.fst ⟨k, c⟩.fst)) y = ⟨j, b⟩.snd
e₄ :
(ConcreteCategory.hom (D.f ⟨k, c⟩.fst ⟨j, b⟩.fst)) ((ConcreteCategory.hom (D.t ⟨j, b⟩.fst ⟨k, c⟩.fst)) y) = ⟨k, c⟩.snd
z : ↑(pullback (D.f j i) (D.f j k)) :=
(ConcreteCategory.hom (pullbackIsoProdSubtype (D.f j i) (D.f j k)).inv)
⟨((ConcreteCategory.hom (D.t ⟨i, a⟩.fst ⟨j, b⟩.fst)) x, y), ⋯⟩
⊢ D.Rel ⟨i, a⟩ ⟨k, c⟩
|
ff5fea99544ad2bd
|
ContinuousMap.sublattice_closure_eq_top
|
Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean
|
theorem sublattice_closure_eq_top (L : Set C(X, ℝ)) (nA : L.Nonempty)
(inf_mem : ∀ᵉ (f ∈ L) (g ∈ L), f ⊓ g ∈ L)
(sup_mem : ∀ᵉ (f ∈ L) (g ∈ L), f ⊔ g ∈ L) (sep : L.SeparatesPointsStrongly) :
closure L = ⊤
|
case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : L.Nonempty
inf_mem : ∀ f ∈ L, ∀ g ∈ L, f ⊓ g ∈ L
sup_mem : ∀ f ∈ L, ∀ g ∈ L, f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f ∈ L, f x = v x ∧ f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), (g x y) x = f x
w₂ : ∀ (x y : X), (g x y) y = f y
U : X → X → Set X := fun x y => {z | f z - ε < (g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => ⋯.choose
ys_w : ∀ (x : X), ⋃ y ∈ ys x, U x y = ⊤ :=
fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), (ys x).Nonempty
h : X → ↑L := fun x => ⟨(ys x).sup' ⋯ fun y => g x y, ⋯⟩
lt_h : ∀ (x z : X), f z - ε < ↑(h x) z
h_eq : ∀ (x : X), ↑(h x) x = f x
W : X → Set X := fun x => {z | ↑(h x) z < f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := ⋯.choose
xs_w : ⋃ x ∈ xs, W x = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : xs.Nonempty
⊢ ∃ x, dist x f < ε ∧ x ∈ L
|
let k : (L : Type _) :=
⟨xs.inf' xs_nonempty fun x => (h x : C(X, ℝ)),
Finset.inf'_mem _ inf_mem _ _ _ fun x _ => (h x).2⟩
|
case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : L.Nonempty
inf_mem : ∀ f ∈ L, ∀ g ∈ L, f ⊓ g ∈ L
sup_mem : ∀ f ∈ L, ∀ g ∈ L, f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f ∈ L, f x = v x ∧ f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), (g x y) x = f x
w₂ : ∀ (x y : X), (g x y) y = f y
U : X → X → Set X := fun x y => {z | f z - ε < (g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => ⋯.choose
ys_w : ∀ (x : X), ⋃ y ∈ ys x, U x y = ⊤ :=
fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), (ys x).Nonempty
h : X → ↑L := fun x => ⟨(ys x).sup' ⋯ fun y => g x y, ⋯⟩
lt_h : ∀ (x z : X), f z - ε < ↑(h x) z
h_eq : ∀ (x : X), ↑(h x) x = f x
W : X → Set X := fun x => {z | ↑(h x) z < f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := ⋯.choose
xs_w : ⋃ x ∈ xs, W x = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : xs.Nonempty
k : ↑L := ⟨xs.inf' xs_nonempty fun x => ↑(h x), ⋯⟩
⊢ ∃ x, dist x f < ε ∧ x ∈ L
|
fe3c7b7c90fed6eb
|
FiberBundle.exists_trivialization_Icc_subset
|
Mathlib/Topology/FiberBundle/Basic.lean
|
theorem FiberBundle.exists_trivialization_Icc_subset [ConditionallyCompleteLinearOrder B]
[OrderTopology B] [FiberBundle F E] (a b : B) :
∃ e : Trivialization F (π F E), Icc a b ⊆ e.baseSet
|
B : Type u_2
F : Type u_3
inst✝⁶ : TopologicalSpace B
inst✝⁵ : TopologicalSpace F
E : B → Type u_5
inst✝⁴ : TopologicalSpace (TotalSpace F E)
inst✝³ : (b : B) → TopologicalSpace (E b)
inst✝² : ConditionallyCompleteLinearOrder B
inst✝¹ : OrderTopology B
inst✝ : FiberBundle F E
a b : B
ea : Trivialization F TotalSpace.proj
hea : a ∈ ea.baseSet
hab : a ≤ b
s : Set B := {x | x ∈ Icc a b ∧ ∃ e, Icc a x ⊆ e.baseSet}
ha : a ∈ s
sne : s.Nonempty
hsb : b ∈ upperBounds s
sbd : BddAbove s
c : B := sSup s
hsc : IsLUB s c
hc : c ∈ Icc a b
ec : Trivialization F TotalSpace.proj
hec : Icc a c ⊆ ec.baseSet
hlt : c < b
⊢ ∃ d ∈ Ioc c b, ∃ e, Icc a d ⊆ e.baseSet
|
obtain ⟨d, hdcb, hd⟩ : ∃ d ∈ Ioc c b, Ico c d ⊆ ec.baseSet :=
(mem_nhdsGE_iff_exists_mem_Ioc_Ico_subset hlt).1
(mem_nhdsWithin_of_mem_nhds <| IsOpen.mem_nhds ec.open_baseSet (hec ⟨hc.1, le_rfl⟩))
|
case intro.intro
B : Type u_2
F : Type u_3
inst✝⁶ : TopologicalSpace B
inst✝⁵ : TopologicalSpace F
E : B → Type u_5
inst✝⁴ : TopologicalSpace (TotalSpace F E)
inst✝³ : (b : B) → TopologicalSpace (E b)
inst✝² : ConditionallyCompleteLinearOrder B
inst✝¹ : OrderTopology B
inst✝ : FiberBundle F E
a b : B
ea : Trivialization F TotalSpace.proj
hea : a ∈ ea.baseSet
hab : a ≤ b
s : Set B := {x | x ∈ Icc a b ∧ ∃ e, Icc a x ⊆ e.baseSet}
ha : a ∈ s
sne : s.Nonempty
hsb : b ∈ upperBounds s
sbd : BddAbove s
c : B := sSup s
hsc : IsLUB s c
hc : c ∈ Icc a b
ec : Trivialization F TotalSpace.proj
hec : Icc a c ⊆ ec.baseSet
hlt : c < b
d : B
hdcb : d ∈ Ioc c b
hd : Ico c d ⊆ ec.baseSet
⊢ ∃ d ∈ Ioc c b, ∃ e, Icc a d ⊆ e.baseSet
|
0bdc8a2531150ce5
|
Set.preimage_eq
|
Mathlib/Data/Rel.lean
|
theorem preimage_eq (f : α → β) (s : Set β) : f ⁻¹' s = (Function.graph f).preimage s
|
α : Type u_1
β : Type u_2
f : α → β
s : Set β
⊢ f ⁻¹' s = (Function.graph f).preimage s
|
simp [Set.preimage, Rel.preimage, Rel.inv, flip, Rel.image]
|
no goals
|
a2db40cb9d7f6b63
|
IsTopologicalGroup.exists_mulInvClosureNhd
|
Mathlib/Topology/Algebra/OpenSubgroup.lean
|
@[to_additive]
lemma exists_mulInvClosureNhd {W : Set G} (WClopen : IsClopen W) :
∃ T, mulInvClosureNhd T W
|
case h
G : Type u_1
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : IsTopologicalGroup G
inst✝ : CompactSpace G
W : Set G
WClopen : IsClopen W
S : Set G
Smemnhds : S ∈ 𝓝 1
mulclose : W * S ⊆ W
U : Set G
UsubS : U ⊆ S
Uopen : IsOpen U
onememU : 1 ∈ U
⊢ mulInvClosureNhd (U ∩ U⁻¹) W
|
constructor
|
case h.nhd
G : Type u_1
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : IsTopologicalGroup G
inst✝ : CompactSpace G
W : Set G
WClopen : IsClopen W
S : Set G
Smemnhds : S ∈ 𝓝 1
mulclose : W * S ⊆ W
U : Set G
UsubS : U ⊆ S
Uopen : IsOpen U
onememU : 1 ∈ U
⊢ U ∩ U⁻¹ ∈ 𝓝 1
case h.inv
G : Type u_1
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : IsTopologicalGroup G
inst✝ : CompactSpace G
W : Set G
WClopen : IsClopen W
S : Set G
Smemnhds : S ∈ 𝓝 1
mulclose : W * S ⊆ W
U : Set G
UsubS : U ⊆ S
Uopen : IsOpen U
onememU : 1 ∈ U
⊢ (U ∩ U⁻¹)⁻¹ = U ∩ U⁻¹
case h.isOpen
G : Type u_1
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : IsTopologicalGroup G
inst✝ : CompactSpace G
W : Set G
WClopen : IsClopen W
S : Set G
Smemnhds : S ∈ 𝓝 1
mulclose : W * S ⊆ W
U : Set G
UsubS : U ⊆ S
Uopen : IsOpen U
onememU : 1 ∈ U
⊢ IsOpen (U ∩ U⁻¹)
case h.mul
G : Type u_1
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : IsTopologicalGroup G
inst✝ : CompactSpace G
W : Set G
WClopen : IsClopen W
S : Set G
Smemnhds : S ∈ 𝓝 1
mulclose : W * S ⊆ W
U : Set G
UsubS : U ⊆ S
Uopen : IsOpen U
onememU : 1 ∈ U
⊢ W * (U ∩ U⁻¹) ⊆ W
|
839b8de3a333177c
|
Multiset.prod_eq_zero_iff
|
Mathlib/Algebra/BigOperators/Ring/Multiset.lean
|
@[simp] lemma prod_eq_zero_iff : s.prod = 0 ↔ (0 : α) ∈ s :=
Quotient.inductionOn s fun l ↦ by rw [quot_mk_to_coe, prod_coe]; exact List.prod_eq_zero_iff
|
α : Type u_2
inst✝² : CommMonoidWithZero α
inst✝¹ : NoZeroDivisors α
inst✝ : Nontrivial α
s : Multiset α
l : List α
⊢ l.prod = 0 ↔ 0 ∈ ↑l
|
exact List.prod_eq_zero_iff
|
no goals
|
a8ac0f2168c4fc46
|
IsFreeGroupoid.SpanningTree.endIsFree
|
Mathlib/GroupTheory/FreeGroup/NielsenSchreier.lean
|
/-- Given a free groupoid and an arborescence of its generating quiver, the vertex
group at the root is freely generated by loops coming from generating arrows
in the complement of the tree. -/
lemma endIsFree : IsFreeGroup (End (root' T)) :=
IsFreeGroup.ofUniqueLift ((wideSubquiverEquivSetTotal <| wideSubquiverSymmetrify T)ᶜ : Set _)
(fun e => loopOfHom T (of e.val.hom))
(by
intro X _ f
let f' : Labelling (Generators G) X := fun a b e =>
if h : e ∈ wideSubquiverSymmetrify T a b then 1 else f ⟨⟨a, b, e⟩, h⟩
rcases unique_lift f' with ⟨F', hF', uF'⟩
refine ⟨F'.mapEnd _, ?_, ?_⟩
· suffices ∀ {x y} (q : x ⟶ y), F'.map (loopOfHom T q) = (F'.map q : X) by
rintro ⟨⟨a, b, e⟩, h⟩
erw [Functor.mapEnd_apply, this, hF']
exact dif_neg h
intros x y q
suffices ∀ {a} (p : Path (root T) a), F'.map (homOfPath T p) = 1 by
simp only [this, treeHom, comp_as_mul, inv_as_inv, loopOfHom, inv_one, mul_one,
one_mul, Functor.map_inv, Functor.map_comp]
intro a p
induction' p with b c p e ih
· rw [homOfPath, F'.map_id, id_as_one]
rw [homOfPath, F'.map_comp, comp_as_mul, ih, mul_one]
rcases e with ⟨e | e, eT⟩
· rw [hF']
exact dif_pos (Or.inl eT)
· rw [F'.map_inv, inv_as_inv, inv_eq_one, hF']
exact dif_pos (Or.inr eT)
· intro E hE
ext x
suffices (functorOfMonoidHom T E).map x = F'.map x by
simpa only [loopOfHom, functorOfMonoidHom, IsIso.inv_id, treeHom_root,
Category.id_comp, Category.comp_id] using this
congr
apply uF'
intro a b e
change E (loopOfHom T _) = dite _ _ _
split_ifs with h
· rw [loopOfHom_eq_id T e h, ← End.one_def, E.map_one]
· exact hE ⟨⟨a, b, e⟩, h⟩)
|
G : Type u
inst✝³ : Groupoid G
inst✝² : IsFreeGroupoid G
T : WideSubquiver (Symmetrify (Generators G))
inst✝¹ : Arborescence (WideSubquiver.toType (Symmetrify (Generators G)) T)
X : Type u
inst✝ : Group X
f : ↑(wideSubquiverEquivSetTotal (wideSubquiverSymmetrify T))ᶜ → X
f' : Labelling (Generators G) X :=
fun a b e => if h : e ∈ wideSubquiverSymmetrify T a b then 1 else f ⟨{ left := a, right := b, hom := e }, h⟩
F' : G ⥤ CategoryTheory.SingleObj X
hF' : ∀ (a b : Generators G) (g : a ⟶ b), F'.map (of g) = f' g
uF' :
∀ (y : G ⥤ CategoryTheory.SingleObj X), (fun F => ∀ (a b : Generators G) (g : a ⟶ b), F.map (of g) = f' g) y → y = F'
this : ∀ {x y : G} (q : x ⟶ y), F'.map (loopOfHom T q) = F'.map q
⊢ (fun F =>
∀ (a : ↑(wideSubquiverEquivSetTotal (wideSubquiverSymmetrify T))ᶜ),
F ((fun e => loopOfHom T (of (↑e).hom)) a) = f a)
(Functor.mapEnd (IsFreeGroupoid.SpanningTree.root' T) F')
|
rintro ⟨⟨a, b, e⟩, h⟩
|
case mk.mk
G : Type u
inst✝³ : Groupoid G
inst✝² : IsFreeGroupoid G
T : WideSubquiver (Symmetrify (Generators G))
inst✝¹ : Arborescence (WideSubquiver.toType (Symmetrify (Generators G)) T)
X : Type u
inst✝ : Group X
f : ↑(wideSubquiverEquivSetTotal (wideSubquiverSymmetrify T))ᶜ → X
f' : Labelling (Generators G) X :=
fun a b e => if h : e ∈ wideSubquiverSymmetrify T a b then 1 else f ⟨{ left := a, right := b, hom := e }, h⟩
F' : G ⥤ CategoryTheory.SingleObj X
hF' : ∀ (a b : Generators G) (g : a ⟶ b), F'.map (of g) = f' g
uF' :
∀ (y : G ⥤ CategoryTheory.SingleObj X), (fun F => ∀ (a b : Generators G) (g : a ⟶ b), F.map (of g) = f' g) y → y = F'
this : ∀ {x y : G} (q : x ⟶ y), F'.map (loopOfHom T q) = F'.map q
a b : Generators G
e : a ⟶ b
h : { left := a, right := b, hom := e } ∈ (wideSubquiverEquivSetTotal (wideSubquiverSymmetrify T))ᶜ
⊢ (Functor.mapEnd (IsFreeGroupoid.SpanningTree.root' T) F')
((fun e => loopOfHom T (of (↑e).hom)) ⟨{ left := a, right := b, hom := e }, h⟩) =
f ⟨{ left := a, right := b, hom := e }, h⟩
|
4742e81f46ca4ae4
|
Multiset.dvd_gcd
|
Mathlib/Algebra/GCDMonoid/Multiset.lean
|
theorem dvd_gcd {s : Multiset α} {a : α} : a ∣ s.gcd ↔ ∀ b ∈ s, a ∣ b :=
Multiset.induction_on s (by simp)
(by simp +contextual [or_imp, forall_and, dvd_gcd_iff])
|
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s : Multiset α
a : α
⊢ ∀ (a_1 : α) (s : Multiset α), (a ∣ s.gcd ↔ ∀ b ∈ s, a ∣ b) → (a ∣ (a_1 ::ₘ s).gcd ↔ ∀ b ∈ a_1 ::ₘ s, a ∣ b)
|
simp +contextual [or_imp, forall_and, dvd_gcd_iff]
|
no goals
|
d31ce47f486f81e6
|
Turing.ToPartrec.Code.exists_code
|
Mathlib/Computability/TMConfig.lean
|
theorem exists_code {n} {f : List.Vector ℕ n →. ℕ} (hf : Nat.Partrec' f) :
∃ c : Code, ∀ v : List.Vector ℕ n, c.eval v.1 = pure <$> f v
|
case neg
n✝¹ : ℕ
f✝ : List.Vector ℕ n✝¹ →. ℕ
n✝ : ℕ
f : List.Vector ℕ (n✝ + 1) → ℕ
a✝ : Nat.Partrec' ↑f
cf : Code
v : List.Vector ℕ n✝
hf : ∀ (a : ℕ), cf.eval (a :: ↑v) = Part.some [f (a ::ᵥ v)]
v' v₀ : List ℕ
n : ℕ
h2 :
v' ∈
PFun.fix
(fun v =>
(cf.eval v).bind fun y =>
Part.some (if y.headI = 0 then Sum.inl (v.headI.succ :: v.tail) else Sum.inr (v.headI.succ :: v.tail)))
(n :: ↑v)
IH :
∀ (a'' : List ℕ),
(Sum.inr a'' ∈
(cf.eval (n :: ↑v)).bind fun y =>
Part.some
(if y.headI = 0 then Sum.inl ((n :: ↑v).headI.succ :: (n :: ↑v).tail)
else Sum.inr ((n :: ↑v).headI.succ :: (n :: ↑v).tail))) →
∀ (n : ℕ),
a'' = n :: ↑v →
(∀ m < n, ¬f (m ::ᵥ v) = 0) →
∃ a, (f (a ::ᵥ v) = 0 ∧ ∀ {m : ℕ}, m < a → ¬f (m ::ᵥ v) = 0) ∧ [a] = [v'.headI.pred]
hm : ∀ m < n, ¬f (m ::ᵥ v) = 0
h : ¬[f (n ::ᵥ v)].headI = 0
this :
Sum.inl v' ∈ Part.some (Sum.inr ((n :: ↑v).headI.succ :: (n :: ↑v).tail)) ∨
∃ a',
Sum.inr a' ∈ Part.some (Sum.inr ((n :: ↑v).headI.succ :: (n :: ↑v).tail)) ∧
v' ∈
PFun.fix
(fun v =>
(cf.eval v).bind fun y =>
Part.some (if y.headI = 0 then Sum.inl (v.headI.succ :: v.tail) else Sum.inr (v.headI.succ :: v.tail)))
a'
⊢ ∃ a, (f (a ::ᵥ v) = 0 ∧ ∀ {m : ℕ}, m < a → ¬f (m ::ᵥ v) = 0) ∧ [a] = [v'.headI.pred]
|
refine IH (n.succ::v.val) (by simp_all) _ rfl fun m h' => ?_
|
case neg
n✝¹ : ℕ
f✝ : List.Vector ℕ n✝¹ →. ℕ
n✝ : ℕ
f : List.Vector ℕ (n✝ + 1) → ℕ
a✝ : Nat.Partrec' ↑f
cf : Code
v : List.Vector ℕ n✝
hf : ∀ (a : ℕ), cf.eval (a :: ↑v) = Part.some [f (a ::ᵥ v)]
v' v₀ : List ℕ
n : ℕ
h2 :
v' ∈
PFun.fix
(fun v =>
(cf.eval v).bind fun y =>
Part.some (if y.headI = 0 then Sum.inl (v.headI.succ :: v.tail) else Sum.inr (v.headI.succ :: v.tail)))
(n :: ↑v)
IH :
∀ (a'' : List ℕ),
(Sum.inr a'' ∈
(cf.eval (n :: ↑v)).bind fun y =>
Part.some
(if y.headI = 0 then Sum.inl ((n :: ↑v).headI.succ :: (n :: ↑v).tail)
else Sum.inr ((n :: ↑v).headI.succ :: (n :: ↑v).tail))) →
∀ (n : ℕ),
a'' = n :: ↑v →
(∀ m < n, ¬f (m ::ᵥ v) = 0) →
∃ a, (f (a ::ᵥ v) = 0 ∧ ∀ {m : ℕ}, m < a → ¬f (m ::ᵥ v) = 0) ∧ [a] = [v'.headI.pred]
hm : ∀ m < n, ¬f (m ::ᵥ v) = 0
h : ¬[f (n ::ᵥ v)].headI = 0
this :
Sum.inl v' ∈ Part.some (Sum.inr ((n :: ↑v).headI.succ :: (n :: ↑v).tail)) ∨
∃ a',
Sum.inr a' ∈ Part.some (Sum.inr ((n :: ↑v).headI.succ :: (n :: ↑v).tail)) ∧
v' ∈
PFun.fix
(fun v =>
(cf.eval v).bind fun y =>
Part.some (if y.headI = 0 then Sum.inl (v.headI.succ :: v.tail) else Sum.inr (v.headI.succ :: v.tail)))
a'
m : ℕ
h' : m < n.succ
⊢ ¬f (m ::ᵥ v) = 0
|
01823c87e1740c3b
|
ContDiffWithinAt.differentiableWithinAt_iteratedFDerivWithin
|
Mathlib/Analysis/Calculus/ContDiff/Defs.lean
|
theorem ContDiffWithinAt.differentiableWithinAt_iteratedFDerivWithin {m : ℕ}
(h : ContDiffWithinAt 𝕜 n f s x) (hmn : m < n) (hs : UniqueDiffOn 𝕜 (insert x s)) :
DifferentiableWithinAt 𝕜 (iteratedFDerivWithin 𝕜 m f s) s x
|
case intro.intro.intro
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type uE
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type uF
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
s : Set E
f : E → F
x : E
n : WithTop ℕ∞
m : ℕ
h : ContDiffWithinAt 𝕜 n f s x
hmn : ↑m < n
hs : UniqueDiffOn 𝕜 (insert x s)
this : ↑m + 1 ≠ ∞
u : Set E
uo : IsOpen u
xu : x ∈ u
t : Set E := insert x s ∩ u
hu : ContDiffOn 𝕜 (↑(m + 1)) f t
A : t =ᶠ[𝓝[≠] x] s
B : iteratedFDerivWithin 𝕜 m f s =ᶠ[𝓝 x] iteratedFDerivWithin 𝕜 m f t
⊢ DifferentiableWithinAt 𝕜 (iteratedFDerivWithin 𝕜 m f s) s x
|
have C : DifferentiableWithinAt 𝕜 (iteratedFDerivWithin 𝕜 m f t) t x :=
hu.differentiableOn_iteratedFDerivWithin (Nat.cast_lt.2 m.lt_succ_self) (hs.inter uo) x
⟨mem_insert _ _, xu⟩
|
case intro.intro.intro
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type uE
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type uF
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
s : Set E
f : E → F
x : E
n : WithTop ℕ∞
m : ℕ
h : ContDiffWithinAt 𝕜 n f s x
hmn : ↑m < n
hs : UniqueDiffOn 𝕜 (insert x s)
this : ↑m + 1 ≠ ∞
u : Set E
uo : IsOpen u
xu : x ∈ u
t : Set E := insert x s ∩ u
hu : ContDiffOn 𝕜 (↑(m + 1)) f t
A : t =ᶠ[𝓝[≠] x] s
B : iteratedFDerivWithin 𝕜 m f s =ᶠ[𝓝 x] iteratedFDerivWithin 𝕜 m f t
C : DifferentiableWithinAt 𝕜 (iteratedFDerivWithin 𝕜 m f t) t x
⊢ DifferentiableWithinAt 𝕜 (iteratedFDerivWithin 𝕜 m f s) s x
|
028f7d28b24d29ba
|
ProbabilityTheory.IsMeasurableRatCDF.monotone_stieltjesFunctionAux
|
Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
|
lemma IsMeasurableRatCDF.monotone_stieltjesFunctionAux (a : α) :
Monotone (IsMeasurableRatCDF.stieltjesFunctionAux f a)
|
α : Type u_1
f : α → ℚ → ℝ
inst✝ : MeasurableSpace α
hf : IsMeasurableRatCDF f
a : α
x y : ℝ
hxy : x ≤ y
⊢ Nonempty { r' // y < ↑r' }
|
obtain ⟨r, hrx⟩ := exists_rat_gt y
|
case intro
α : Type u_1
f : α → ℚ → ℝ
inst✝ : MeasurableSpace α
hf : IsMeasurableRatCDF f
a : α
x y : ℝ
hxy : x ≤ y
r : ℚ
hrx : y < ↑r
⊢ Nonempty { r' // y < ↑r' }
|
b8b32d0abfad29b9
|
Real.continuousAt_rpow_of_ne
|
Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean
|
theorem continuousAt_rpow_of_ne (p : ℝ × ℝ) (hp : p.1 ≠ 0) :
ContinuousAt (fun p : ℝ × ℝ => p.1 ^ p.2) p
|
case inl
p : ℝ × ℝ
hp : p.1 < 0
⊢ ContinuousAt (fun p => p.1 ^ p.2) p
|
rw [continuousAt_congr (rpow_eq_nhds_of_neg hp)]
|
case inl
p : ℝ × ℝ
hp : p.1 < 0
⊢ ContinuousAt (fun x => rexp (log x.1 * x.2) * cos (x.2 * π)) p
|
2e69ae2bc8a153ac
|
NumberField.mixedEmbedding.volume_preserving_negAt
|
Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
|
theorem volume_preserving_negAt [NumberField K] :
MeasurePreserving (negAt s)
|
case pos
K : Type u_1
inst✝¹ : Field K
s : Set { w // w.IsReal }
inst✝ : NumberField K
w : { w // w.IsReal }
hw : w ∈ s
⊢ MeasurePreserving (↑(neg ℝ).toLinearEquiv).toAddHom.1 volume volume
|
exact Measure.measurePreserving_neg _
|
no goals
|
299b1d1145ec3899
|
Ideal.map_mk_comap_factor
|
Mathlib/RingTheory/Ideal/Quotient/PowTransition.lean
|
lemma Ideal.map_mk_comap_factor [J.IsTwoSided] [K.IsTwoSided] (hIJ : J ≤ I) (hJK : K ≤ J) :
(I.map (mk J)).comap (factor hJK) = I.map (mk K)
|
case h.refine_2.intro.intro
R : Type u_1
inst✝² : Ring R
I J K : Ideal R
inst✝¹ : J.IsTwoSided
inst✝ : K.IsTwoSided
hIJ : J ≤ I
hJK : K ≤ J
x : R ⧸ K
h : x ∈ map (mk K) I
r : R
hr : r ∈ ↑I
eq : (mk K) r = x
⊢ x ∈ comap (factor hJK) (map (mk J) I)
|
simpa only [← eq] using mem_map_of_mem (mk J) hr
|
no goals
|
c5e0a4d45fe78c35
|
Polynomial.support_update
|
Mathlib/Algebra/Polynomial/Basic.lean
|
theorem support_update (p : R[X]) (n : ℕ) (a : R) [Decidable (a = 0)] :
support (p.update n a) = if a = 0 then p.support.erase n else insert n p.support
|
R : Type u
inst✝¹ : Semiring R
p : R[X]
n : ℕ
a : R
inst✝ : Decidable (a = 0)
⊢ (p.update n a).support = if a = 0 then p.support.erase n else insert n p.support
|
cases p
|
case ofFinsupp
R : Type u
inst✝¹ : Semiring R
n : ℕ
a : R
inst✝ : Decidable (a = 0)
toFinsupp✝ : R[ℕ]
⊢ ({ toFinsupp := toFinsupp✝ }.update n a).support =
if a = 0 then { toFinsupp := toFinsupp✝ }.support.erase n else insert n { toFinsupp := toFinsupp✝ }.support
|
4d38e0e4d9b9c2de
|
exteriorPower.pairingDual_apply_apply_eq_one_zero
|
Mathlib/LinearAlgebra/ExteriorPower/Pairing.lean
|
lemma pairingDual_apply_apply_eq_one_zero (a b : Fin n ↪o ι) (h : a ≠ b) :
pairingDual R M n (ιMulti _ _ (f ∘ a)) (ιMulti _ _ (x ∘ b)) = 0
|
R : Type u_1
M : Type u_2
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_3
inst✝ : LinearOrder ι
x : ι → M
f : ι → Module.Dual R M
h₀ : ∀ ⦃i j : ι⦄, i ≠ j → (f i) (x j) = 0
n : ℕ
a b : Fin n ↪o ι
h : a ≠ b
σ : Equiv.Perm (Fin n)
x✝ : σ ∈ Finset.univ
h' : ¬∏ x_1 : Fin n, (f (a x_1)) (x (b (σ x_1))) = 0
this : ⇑a = ⇑b ∘ ⇑σ
i j : Fin n
hij : i ≤ j
⊢ σ i ≤ σ j
|
have h'' := congr_fun this
|
R : Type u_1
M : Type u_2
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_3
inst✝ : LinearOrder ι
x : ι → M
f : ι → Module.Dual R M
h₀ : ∀ ⦃i j : ι⦄, i ≠ j → (f i) (x j) = 0
n : ℕ
a b : Fin n ↪o ι
h : a ≠ b
σ : Equiv.Perm (Fin n)
x✝ : σ ∈ Finset.univ
h' : ¬∏ x_1 : Fin n, (f (a x_1)) (x (b (σ x_1))) = 0
this : ⇑a = ⇑b ∘ ⇑σ
i j : Fin n
hij : i ≤ j
h'' : ∀ (a_1 : Fin n), a a_1 = (⇑b ∘ ⇑σ) a_1
⊢ σ i ≤ σ j
|
fd3ea1bd40177425
|
Bimod.whisker_assoc_bimod
|
Mathlib/CategoryTheory/Monoidal/Bimod.lean
|
theorem whisker_assoc_bimod {W X Y Z : Mon_ C} (M : Bimod W X) {N N' : Bimod X Y} (f : N ⟶ N')
(P : Bimod Y Z) :
whiskerRight (whiskerLeft M f) P =
(associatorBimod M N P).hom ≫
whiskerLeft M (whiskerRight f P) ≫ (associatorBimod M N' P).inv
|
case h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
inst✝² : HasCoequalizers C
inst✝¹ : ∀ (X : C), PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : ∀ (X : C), PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
W X Y Z : Mon_ C
M : Bimod W X
N N' : Bimod X Y
f : N ⟶ N'
P : Bimod Y Z
⊢ coequalizer.π (M.actRight ▷ N.X) ((α_ M.X X.X N.X).hom ≫ M.X ◁ N.actLeft) ▷ P.X ≫
colimMap
(parallelPairHom (M.actRight ▷ N.X) ((α_ M.X X.X N.X).hom ≫ M.X ◁ N.actLeft) (M.actRight ▷ N'.X)
((α_ M.X X.X N'.X).hom ≫ M.X ◁ N'.actLeft) ((M.X ⊗ X.X) ◁ f.hom) (M.X ◁ f.hom) ⋯ ⋯) ▷
P.X ≫
colimit.ι
(parallelPair (TensorBimod.actRight M N' ▷ P.X)
((α_ (TensorBimod.X M N') Y.X P.X).hom ≫ TensorBimod.X M N' ◁ P.actLeft))
WalkingParallelPair.one =
coequalizer.π (M.actRight ▷ N.X) ((α_ M.X X.X N.X).hom ≫ M.X ◁ N.actLeft) ▷ P.X ≫
(((PreservesCoequalizer.iso (tensorRight P.X) (M.actRight ▷ N.X) ((α_ M.X X.X N.X).hom ≫ M.X ◁ N.actLeft)).inv ≫
coequalizer.desc
((α_ M.X N.X P.X).hom ≫
M.X ◁ coequalizer.π (N.actRight ▷ P.X) ((α_ N.X Y.X P.X).hom ≫ N.X ◁ P.actLeft) ≫
coequalizer.π (M.actRight ▷ TensorBimod.X N P)
((α_ M.X X.X (TensorBimod.X N P)).hom ≫ M.X ◁ TensorBimod.actLeft N P))
⋯) ≫
colimMap
(parallelPairHom (M.actRight ▷ TensorBimod.X N P)
((α_ M.X X.X (TensorBimod.X N P)).hom ≫ M.X ◁ TensorBimod.actLeft N P) (M.actRight ▷ TensorBimod.X N' P)
((α_ M.X X.X (TensorBimod.X N' P)).hom ≫ M.X ◁ TensorBimod.actLeft N' P)
((M.X ⊗ X.X) ◁
colimMap
(parallelPairHom (N.actRight ▷ P.X) ((α_ N.X Y.X P.X).hom ≫ N.X ◁ P.actLeft) (N'.actRight ▷ P.X)
((α_ N'.X Y.X P.X).hom ≫ N'.X ◁ P.actLeft) (f.hom ▷ Y.X ▷ P.X) (f.hom ▷ P.X) ⋯ ⋯))
(M.X ◁
colimMap
(parallelPairHom (N.actRight ▷ P.X) ((α_ N.X Y.X P.X).hom ≫ N.X ◁ P.actLeft) (N'.actRight ▷ P.X)
((α_ N'.X Y.X P.X).hom ≫ N'.X ◁ P.actLeft) (f.hom ▷ Y.X ▷ P.X) (f.hom ▷ P.X) ⋯ ⋯))
⋯ ⋯)) ≫
AssociatorBimod.inv M N' P
|
slice_lhs 1 2 => rw [← comp_whiskerRight, ι_colimMap, parallelPairHom_app_one]
|
case h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
inst✝² : HasCoequalizers C
inst✝¹ : ∀ (X : C), PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : ∀ (X : C), PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
W X Y Z : Mon_ C
M : Bimod W X
N N' : Bimod X Y
f : N ⟶ N'
P : Bimod Y Z
⊢ (M.X ◁ f.hom ≫
colimit.ι (parallelPair (M.actRight ▷ N'.X) ((α_ M.X X.X N'.X).hom ≫ M.X ◁ N'.actLeft))
WalkingParallelPair.one) ▷
P.X ≫
colimit.ι
(parallelPair (TensorBimod.actRight M N' ▷ P.X)
((α_ (TensorBimod.X M N') Y.X P.X).hom ≫ TensorBimod.X M N' ◁ P.actLeft))
WalkingParallelPair.one =
coequalizer.π (M.actRight ▷ N.X) ((α_ M.X X.X N.X).hom ≫ M.X ◁ N.actLeft) ▷ P.X ≫
(((PreservesCoequalizer.iso (tensorRight P.X) (M.actRight ▷ N.X) ((α_ M.X X.X N.X).hom ≫ M.X ◁ N.actLeft)).inv ≫
coequalizer.desc
((α_ M.X N.X P.X).hom ≫
M.X ◁ coequalizer.π (N.actRight ▷ P.X) ((α_ N.X Y.X P.X).hom ≫ N.X ◁ P.actLeft) ≫
coequalizer.π (M.actRight ▷ TensorBimod.X N P)
((α_ M.X X.X (TensorBimod.X N P)).hom ≫ M.X ◁ TensorBimod.actLeft N P))
⋯) ≫
colimMap
(parallelPairHom (M.actRight ▷ TensorBimod.X N P)
((α_ M.X X.X (TensorBimod.X N P)).hom ≫ M.X ◁ TensorBimod.actLeft N P) (M.actRight ▷ TensorBimod.X N' P)
((α_ M.X X.X (TensorBimod.X N' P)).hom ≫ M.X ◁ TensorBimod.actLeft N' P)
((M.X ⊗ X.X) ◁
colimMap
(parallelPairHom (N.actRight ▷ P.X) ((α_ N.X Y.X P.X).hom ≫ N.X ◁ P.actLeft) (N'.actRight ▷ P.X)
((α_ N'.X Y.X P.X).hom ≫ N'.X ◁ P.actLeft) (f.hom ▷ Y.X ▷ P.X) (f.hom ▷ P.X) ⋯ ⋯))
(M.X ◁
colimMap
(parallelPairHom (N.actRight ▷ P.X) ((α_ N.X Y.X P.X).hom ≫ N.X ◁ P.actLeft) (N'.actRight ▷ P.X)
((α_ N'.X Y.X P.X).hom ≫ N'.X ◁ P.actLeft) (f.hom ▷ Y.X ▷ P.X) (f.hom ▷ P.X) ⋯ ⋯))
⋯ ⋯)) ≫
AssociatorBimod.inv M N' P
|
64d3d49872bb8a8d
|
Vector.find?_toList
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Vector/Lemmas.lean
|
theorem find?_toList (p : α → Bool) (v : Vector α n) :
v.toList.find? p = v.find? p
|
α : Type
n : Nat
p : α → Bool
v : Vector α n
⊢ List.find? p v.toList = find? p v
|
cases v
|
case mk
α : Type
n : Nat
p : α → Bool
toArray✝ : Array α
size_toArray✝ : toArray✝.size = n
⊢ List.find? p { toArray := toArray✝, size_toArray := size_toArray✝ }.toList =
find? p { toArray := toArray✝, size_toArray := size_toArray✝ }
|
36dd87d502ce7afa
|
LinearIndependent.map_pow_expChar_pow_of_fd_isSeparable
|
Mathlib/FieldTheory/PurelyInseparable/PerfectClosure.lean
|
theorem LinearIndependent.map_pow_expChar_pow_of_fd_isSeparable
[FiniteDimensional F E] [Algebra.IsSeparable F E]
(h : LinearIndependent F v) : LinearIndependent F (v · ^ q ^ n)
|
case h.e'_4.h
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
q n : ℕ
hF : ExpChar F q
ι : Type u_1
v : ι → E
inst✝¹ : FiniteDimensional F E
inst✝ : Algebra.IsSeparable F E
h : LinearIndependent F v
h' : LinearIndepOn F id (Set.range v)
ι' : Set E := h'.extend ⋯
b : Basis (↑ι') F E := Basis.extend h'
this : Fintype ↑ι' := FiniteDimensional.fintypeBasisIndex b
H : LinearIndependent F fun (x : ↑ι') => b x ^ q ^ n
f : ι → ↑ι' := fun i => ⟨v i, ⋯⟩
x✝ : ι
⊢ v x✝ ^ q ^ n = (Basis.extend h') (f x✝) ^ q ^ n
|
rw [Basis.extend_apply_self]
|
no goals
|
ad56485109349825
|
nhdsSet_univ
|
Mathlib/Topology/NhdsSet.lean
|
theorem nhdsSet_univ : 𝓝ˢ (univ : Set X) = ⊤
|
X : Type u_1
inst✝ : TopologicalSpace X
⊢ 𝓝ˢ univ = ⊤
|
rw [isOpen_univ.nhdsSet_eq, principal_univ]
|
no goals
|
b67f0727997ec829
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.denote_blastDivSubtractShift_r
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Udiv.lean
|
theorem denote_blastDivSubtractShift_r (aig : AIG α) (assign : α → Bool) (lhs rhs : BitVec w)
(falseRef trueRef : AIG.Ref aig) (n d : AIG.RefVec aig w) (wn wr : Nat)
(q r : AIG.RefVec aig w) (qbv rbv : BitVec w)
(hleft : ∀ (idx : Nat) (hidx : idx < w), ⟦aig, n.get idx hidx, assign⟧ = lhs.getLsbD idx)
(hright : ∀ (idx : Nat) (hidx : idx < w), ⟦aig, d.get idx hidx, assign⟧ = rhs.getLsbD idx)
(hr : ∀ (idx : Nat) (hidx : idx < w), ⟦aig, r.get idx hidx, assign⟧ = rbv.getLsbD idx)
(hfalse : ⟦aig, falseRef, assign⟧ = false)
:
∀ (idx : Nat) (hidx : idx < w),
⟦
(blastDivSubtractShift aig falseRef trueRef n d wn wr q r).aig,
(blastDivSubtractShift aig falseRef trueRef n d wn wr q r).r.get idx hidx,
assign
⟧
=
(BitVec.divSubtractShift { n := lhs, d := rhs } { wn := wn, wr := wr, q := qbv, r := rbv }).r.getLsbD idx
|
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
assign : α → Bool
lhs rhs : BitVec w
falseRef trueRef : aig.Ref
n d : aig.RefVec w
wn wr : Nat
q r : aig.RefVec w
qbv rbv : BitVec w
hleft : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := n.get idx hidx }⟧ = lhs.getLsbD idx
hright : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := d.get idx hidx }⟧ = rhs.getLsbD idx
hr : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := r.get idx hidx }⟧ = rbv.getLsbD idx
hfalse : ⟦assign, { aig := aig, ref := falseRef }⟧ = false
idx : Nat
hidx : idx < w
⊢ (if
⟦assign,
BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{ lhs := ((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯).cast ⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }⟧ =
true then
⟦assign,
{
aig :=
(RefVec.ite
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).aig
{
discr :=
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).ref,
lhs :=
(((blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).vec.cast
⋯).cast
⋯).cast
⋯,
rhs :=
((blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).vec.cast
⋯).cast
⋯ }).aig,
ref :=
((((((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.get idx hidx).cast ⋯).cast
⋯).cast
⋯).cast
⋯).cast
⋯ }⟧
else
⟦assign,
{
aig :=
(RefVec.ite
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).aig
{
discr :=
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).ref,
lhs :=
(((blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).vec.cast
⋯).cast
⋯).cast
⋯,
rhs :=
((blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).vec.cast
⋯).cast
⋯ }).aig,
ref :=
(((blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).vec.get
idx hidx).cast
⋯).cast
⋯ }⟧) =
(if rbv.shiftConcat (lhs.getLsbD (wn - 1)) < rhs then
{ wn := wn - 1, wr := wr + 1, q := qbv.shiftConcat false, r := rbv.shiftConcat (lhs.getLsbD (wn - 1)) }
else
{ wn := wn - 1, wr := wr + 1, q := qbv.shiftConcat true,
r := rbv.shiftConcat (lhs.getLsbD (wn - 1)) - rhs }).r.getLsbD
idx
|
rw [BVPred.mkUlt_denote_eq (lhs := rbv.shiftConcat (lhs.getLsbD (wn - 1))) (rhs := rhs)]
|
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
assign : α → Bool
lhs rhs : BitVec w
falseRef trueRef : aig.Ref
n d : aig.RefVec w
wn wr : Nat
q r : aig.RefVec w
qbv rbv : BitVec w
hleft : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := n.get idx hidx }⟧ = lhs.getLsbD idx
hright : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := d.get idx hidx }⟧ = rhs.getLsbD idx
hr : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := r.get idx hidx }⟧ = rbv.getLsbD idx
hfalse : ⟦assign, { aig := aig, ref := falseRef }⟧ = false
idx : Nat
hidx : idx < w
⊢ (if (rbv.shiftConcat (lhs.getLsbD (wn - 1))).ult rhs = true then
⟦assign,
{
aig :=
(RefVec.ite
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).aig
{
discr :=
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).ref,
lhs :=
(((blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).vec.cast
⋯).cast
⋯).cast
⋯,
rhs :=
((blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).vec.cast
⋯).cast
⋯ }).aig,
ref :=
((((((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.get idx hidx).cast ⋯).cast
⋯).cast
⋯).cast
⋯).cast
⋯ }⟧
else
⟦assign,
{
aig :=
(RefVec.ite
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).aig
{
discr :=
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).ref,
lhs :=
(((blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).vec.cast
⋯).cast
⋯).cast
⋯,
rhs :=
((blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).vec.cast
⋯).cast
⋯ }).aig,
ref :=
(((blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).vec.get
idx hidx).cast
⋯).cast
⋯ }⟧) =
(if rbv.shiftConcat (lhs.getLsbD (wn - 1)) < rhs then
{ wn := wn - 1, wr := wr + 1, q := qbv.shiftConcat false, r := rbv.shiftConcat (lhs.getLsbD (wn - 1)) }
else
{ wn := wn - 1, wr := wr + 1, q := qbv.shiftConcat true,
r := rbv.shiftConcat (lhs.getLsbD (wn - 1)) - rhs }).r.getLsbD
idx
case hleft
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
assign : α → Bool
lhs rhs : BitVec w
falseRef trueRef : aig.Ref
n d : aig.RefVec w
wn wr : Nat
q r : aig.RefVec w
qbv rbv : BitVec w
hleft : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := n.get idx hidx }⟧ = lhs.getLsbD idx
hright : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := d.get idx hidx }⟧ = rhs.getLsbD idx
hr : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := r.get idx hidx }⟧ = rbv.getLsbD idx
hfalse : ⟦assign, { aig := aig, ref := falseRef }⟧ = false
idx : Nat
hidx : idx < w
⊢ ∀ (idx : Nat) (hidx : idx < w),
⟦assign,
{
aig :=
(blastSub
(blastShiftConcat
(blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{ lhs := ((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig,
ref :=
{ lhs := (((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯).cast ⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }.lhs.get
idx hidx }⟧ =
(rbv.shiftConcat (lhs.getLsbD (wn - 1))).getLsbD idx
case hright
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
assign : α → Bool
lhs rhs : BitVec w
falseRef trueRef : aig.Ref
n d : aig.RefVec w
wn wr : Nat
q r : aig.RefVec w
qbv rbv : BitVec w
hleft : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := n.get idx hidx }⟧ = lhs.getLsbD idx
hright : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := d.get idx hidx }⟧ = rhs.getLsbD idx
hr : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := r.get idx hidx }⟧ = rbv.getLsbD idx
hfalse : ⟦assign, { aig := aig, ref := falseRef }⟧ = false
idx : Nat
hidx : idx < w
⊢ ∀ (idx : Nat) (hidx : idx < w),
⟦assign,
{
aig :=
(blastSub
(blastShiftConcat
(blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{ lhs := ((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig,
ref :=
{ lhs := (((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯).cast ⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }.rhs.get
idx hidx }⟧ =
rhs.getLsbD idx
|
249a96ab3a68ac7e
|
lemma₁
|
Mathlib/NumberTheory/LSeries/SumCoeff.lean
|
theorem lemma₁ (hlim : Tendsto (fun n : ℕ ↦ (∑ k ∈ Icc 1 n, f k) / n) atTop (𝓝 l))
{s : ℝ} (hs : 1 < s) :
IntegrableOn (fun t : ℝ ↦ (∑ k ∈ Icc 1 ⌊t⌋₊, f k) * (t : ℂ) ^ (-(s : ℂ) - 1)) (Set.Ici 1)
|
f : ℕ → ℂ
l : ℂ
hlim : Tendsto (fun n => (∑ k ∈ Icc 1 n, f k) / ↑n) atTop (𝓝 l)
s : ℝ
hs : 1 < s
h₁ : LocallyIntegrableOn (fun t => (∑ k ∈ Icc 1 ⌊t⌋₊, f k) * ↑t ^ (-↑s - 1)) (Set.Ici 1) volume
⊢ (fun t => ∑ k ∈ Icc 1 ⌊t⌋₊, f k) =O[atTop] fun t => t
|
refine IsBigO.trans_isEquivalent ?_ isEquivalent_nat_floor
|
f : ℕ → ℂ
l : ℂ
hlim : Tendsto (fun n => (∑ k ∈ Icc 1 n, f k) / ↑n) atTop (𝓝 l)
s : ℝ
hs : 1 < s
h₁ : LocallyIntegrableOn (fun t => (∑ k ∈ Icc 1 ⌊t⌋₊, f k) * ↑t ^ (-↑s - 1)) (Set.Ici 1) volume
⊢ (fun t => ∑ k ∈ Icc 1 ⌊t⌋₊, f k) =O[atTop] fun x => ↑⌊x⌋₊
|
44984ad91259849f
|
Filter.tendsto_const_mul_atTop_iff_pos
|
Mathlib/Order/Filter/AtTopBot/Field.lean
|
theorem tendsto_const_mul_atTop_iff_pos [NeBot l] (h : Tendsto f l atTop) :
Tendsto (fun x => r * f x) l atTop ↔ 0 < r
|
case intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedSemifield α
l : Filter β
f : β → α
r : α
inst✝ : l.NeBot
h : Tendsto f l atTop
hrf : Tendsto (fun x => r * f x) l atTop
hr : r ≤ 0
x : β
hx : 0 ≤ f x
hrx : 0 < r * f x
⊢ False
|
exact (mul_nonpos_of_nonpos_of_nonneg hr hx).not_lt hrx
|
no goals
|
f67b1f5dc7971625
|
AlgebraicGeometry.isCompact_basicOpen
|
Mathlib/AlgebraicGeometry/Morphisms/QuasiCompact.lean
|
theorem isCompact_basicOpen (X : Scheme) {U : X.Opens} (hU : IsCompact (U : Set X))
(f : Γ(X, U)) : IsCompact (X.basicOpen f : Set X)
|
case intro.intro
X : Scheme
U : X.Opens
hU : IsCompact ↑U
f : ↑Γ(X, U)
s : Set ↑X.affineOpens
hs : s.Finite
e : ↑U = ⋃ i ∈ s, ↑↑i
g : ↑s → ↑X.affineOpens := fun V => ⟨↑↑V ⊓ X.basicOpen f, ⋯⟩
this : Finite ↑s
⊢ ⋃ i ∈ s, ↑↑i ∩ ↑(X.toRingedSpace.basicOpen f) = ⋃ i ∈ Set.range g, ↑↑i
|
apply le_antisymm <;> apply Set.iUnion₂_subset
|
case intro.intro.a.h
X : Scheme
U : X.Opens
hU : IsCompact ↑U
f : ↑Γ(X, U)
s : Set ↑X.affineOpens
hs : s.Finite
e : ↑U = ⋃ i ∈ s, ↑↑i
g : ↑s → ↑X.affineOpens := fun V => ⟨↑↑V ⊓ X.basicOpen f, ⋯⟩
this : Finite ↑s
⊢ ∀ i ∈ s, ↑↑i ∩ ↑(X.toRingedSpace.basicOpen f) ⊆ ⋃ i ∈ Set.range g, ↑↑i
case intro.intro.a.h
X : Scheme
U : X.Opens
hU : IsCompact ↑U
f : ↑Γ(X, U)
s : Set ↑X.affineOpens
hs : s.Finite
e : ↑U = ⋃ i ∈ s, ↑↑i
g : ↑s → ↑X.affineOpens := fun V => ⟨↑↑V ⊓ X.basicOpen f, ⋯⟩
this : Finite ↑s
⊢ ∀ i ∈ Set.range g, ↑↑i ⊆ ⋃ i ∈ s, ↑↑i ∩ ↑(X.toRingedSpace.basicOpen f)
|
85d4cb2bab8ba3ba
|
ENNReal.lintegral_Lp_add_le
|
Mathlib/MeasureTheory/Integral/MeanInequalities.lean
|
theorem lintegral_Lp_add_le {p : ℝ} {f g : α → ℝ≥0∞} (hf : AEMeasurable f μ) (hg : AEMeasurable g μ)
(hp1 : 1 ≤ p) :
(∫⁻ a, (f + g) a ^ p ∂μ) ^ (1 / p) ≤
(∫⁻ a, f a ^ p ∂μ) ^ (1 / p) + (∫⁻ a, g a ^ p ∂μ) ^ (1 / p)
|
α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p : ℝ
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
hg : AEMeasurable g μ
hp1 : 1 ≤ p
hp_pos : 0 < p
hf_top : ¬∫⁻ (a : α), f a ^ p ∂μ = ⊤
hg_top : ¬∫⁻ (a : α), g a ^ p ∂μ = ⊤
h1 : ¬p = 1
⊢ p ≠ 1
|
exact h1
|
no goals
|
917d466c6455bcc8
|
exists_prime_orderOf_dvd_card
|
Mathlib/GroupTheory/Perm/Cycle/Type.lean
|
theorem _root_.exists_prime_orderOf_dvd_card {G : Type*} [Group G] [Fintype G] (p : ℕ)
[hp : Fact p.Prime] (hdvd : p ∣ Fintype.card G) : ∃ x : G, orderOf x = p
|
G : Type u_3
inst✝¹ : Group G
inst✝ : Fintype G
p : ℕ
hp : Fact (Nat.Prime p)
hdvd : p ∣ Fintype.card G
hp' : p - 1 ≠ 0
Scard : p ∣ Fintype.card ↑(vectorsProdEqOne G p)
f : ℕ → ↑(vectorsProdEqOne G p) → ↑(vectorsProdEqOne G p) := fun k v => VectorsProdEqOne.rotate v k
hf1 : ∀ (v : ↑(vectorsProdEqOne G p)), f 0 v = v
hf2 : ∀ (j k : ℕ) (v : ↑(vectorsProdEqOne G p)), f k (f j v) = f (j + k) v
hf3 : ∀ (v : ↑(vectorsProdEqOne G p)), f p v = v
s : ↑(vectorsProdEqOne G p)
⊢ f (p - 1) (f 1 s) = s
|
rw [hf2, add_tsub_cancel_of_le hp.out.one_lt.le, hf3]
|
no goals
|
8d70eb3bee101171
|
Monoid.exponent_prod
|
Mathlib/GroupTheory/Exponent.lean
|
theorem Monoid.exponent_prod {M₁ M₂ : Type*} [Monoid M₁] [Monoid M₂] :
exponent (M₁ × M₂) = lcm (exponent M₁) (exponent M₂)
|
case refine_1
M₁ : Type u_1
M₂ : Type u_2
inst✝¹ : Monoid M₁
inst✝ : Monoid M₂
⊢ exponent (M₁ × M₂) ∣ GCDMonoid.lcm (exponent M₁) (exponent M₂)
|
refine exponent_dvd_of_forall_pow_eq_one fun g ↦ ?_
|
case refine_1
M₁ : Type u_1
M₂ : Type u_2
inst✝¹ : Monoid M₁
inst✝ : Monoid M₂
g : M₁ × M₂
⊢ g ^ GCDMonoid.lcm (exponent M₁) (exponent M₂) = 1
|
6a9d76694de00ba8
|
refinement_of_locallyCompact_sigmaCompact_of_nhds_basis_set
|
Mathlib/Topology/Compactness/Paracompact.lean
|
theorem refinement_of_locallyCompact_sigmaCompact_of_nhds_basis_set [WeaklyLocallyCompactSpace X]
[SigmaCompactSpace X] [T2Space X] {ι : X → Type u} {p : ∀ x, ι x → Prop} {B : ∀ x, ι x → Set X}
{s : Set X} (hs : IsClosed s) (hB : ∀ x ∈ s, (𝓝 x).HasBasis (p x) (B x)) :
∃ (α : Type v) (c : α → X) (r : ∀ a, ι (c a)),
(∀ a, c a ∈ s ∧ p (c a) (r a)) ∧
(s ⊆ ⋃ a, B (c a) (r a)) ∧ LocallyFinite fun a ↦ B (c a) (r a)
|
case refine_2
X : Type v
inst✝³ : TopologicalSpace X
inst✝² : WeaklyLocallyCompactSpace X
inst✝¹ : SigmaCompactSpace X
inst✝ : T2Space X
ι : X → Type u
p : (x : X) → ι x → Prop
B : (x : X) → ι x → Set X
s : Set X
hs : IsClosed s
hB : ∀ x ∈ s, (𝓝 x).HasBasis (p x) (B x)
K' : CompactExhaustion X := CompactExhaustion.choice X
K : CompactExhaustion X := K'.shiftr.shiftr
Kdiff : ℕ → Set X := fun n => K (n + 1) \ interior (K n)
hKcov : ∀ (x : X), x ∈ Kdiff (K'.find x + 1)
Kdiffc : ∀ (n : ℕ), IsCompact (Kdiff n ∩ s)
this : ∀ (n : ℕ) (x : ↑(Kdiff (n + 1) ∩ s)), (K n)ᶜ ∈ 𝓝 ↑x
r : (n : ℕ) → (x : ↑(Kdiff (n + 1) ∩ s)) → ι ↑x
hrp : ∀ (n : ℕ) (x : ↑(Kdiff (n + 1) ∩ s)), p (↑x) (r n x)
hr : ∀ (n : ℕ) (x : ↑(Kdiff (n + 1) ∩ s)), B (↑x) (r n x) ⊆ (K n)ᶜ
hxr : ∀ (n : ℕ) (x : X) (hx : x ∈ Kdiff (n + 1) ∩ s), B x (r n ⟨x, hx⟩) ∈ 𝓝 x
T : (n : ℕ) → Finset ↑(Kdiff (n + 1) ∩ s)
hT : ∀ (n : ℕ), Kdiff (n + 1) ∩ s ⊆ ⋃ x ∈ T n, B (↑x) (r n ⟨↑x, ⋯⟩)
T' : (n : ℕ) → Set ↑(Kdiff (n + 1) ∩ s) := fun n => ↑(T n)
x : X
hx : x ∈ s
⊢ ∃ i, x ∈ B ((fun a => ↑↑a.snd) i) ((fun a => r a.fst ↑a.snd) i)
|
rcases mem_iUnion₂.1 (hT _ ⟨hKcov x, hx⟩) with ⟨⟨c, hc⟩, hcT, hcx⟩
|
case refine_2.intro.mk.intro
X : Type v
inst✝³ : TopologicalSpace X
inst✝² : WeaklyLocallyCompactSpace X
inst✝¹ : SigmaCompactSpace X
inst✝ : T2Space X
ι : X → Type u
p : (x : X) → ι x → Prop
B : (x : X) → ι x → Set X
s : Set X
hs : IsClosed s
hB : ∀ x ∈ s, (𝓝 x).HasBasis (p x) (B x)
K' : CompactExhaustion X := CompactExhaustion.choice X
K : CompactExhaustion X := K'.shiftr.shiftr
Kdiff : ℕ → Set X := fun n => K (n + 1) \ interior (K n)
hKcov : ∀ (x : X), x ∈ Kdiff (K'.find x + 1)
Kdiffc : ∀ (n : ℕ), IsCompact (Kdiff n ∩ s)
this : ∀ (n : ℕ) (x : ↑(Kdiff (n + 1) ∩ s)), (K n)ᶜ ∈ 𝓝 ↑x
r : (n : ℕ) → (x : ↑(Kdiff (n + 1) ∩ s)) → ι ↑x
hrp : ∀ (n : ℕ) (x : ↑(Kdiff (n + 1) ∩ s)), p (↑x) (r n x)
hr : ∀ (n : ℕ) (x : ↑(Kdiff (n + 1) ∩ s)), B (↑x) (r n x) ⊆ (K n)ᶜ
hxr : ∀ (n : ℕ) (x : X) (hx : x ∈ Kdiff (n + 1) ∩ s), B x (r n ⟨x, hx⟩) ∈ 𝓝 x
T : (n : ℕ) → Finset ↑(Kdiff (n + 1) ∩ s)
hT : ∀ (n : ℕ), Kdiff (n + 1) ∩ s ⊆ ⋃ x ∈ T n, B (↑x) (r n ⟨↑x, ⋯⟩)
T' : (n : ℕ) → Set ↑(Kdiff (n + 1) ∩ s) := fun n => ↑(T n)
x : X
hx : x ∈ s
c : X
hc : c ∈ Kdiff (K'.find x + 1) ∩ s
hcT : ⟨c, hc⟩ ∈ T (K'.find x)
hcx : x ∈ B (↑⟨c, hc⟩) (r (K'.find x) ⟨↑⟨c, hc⟩, ⋯⟩)
⊢ ∃ i, x ∈ B ((fun a => ↑↑a.snd) i) ((fun a => r a.fst ↑a.snd) i)
|
d7d8360667f4b953
|
HNNExtension.NormalWord.of_smul_eq_smul
|
Mathlib/GroupTheory/HNNExtension.lean
|
theorem of_smul_eq_smul (g : G) (w : NormalWord d) :
(of g : HNNExtension G A B φ) • w = g • w
|
G : Type u_1
inst✝ : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
d : TransversalPair G A B
g : G
w : NormalWord d
⊢ of g • w = g • w
|
simp [instHSMul, SMul.smul, MulAction.toEndHom]
|
no goals
|
c79a48fcf81ba796
|
Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastUdiv
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Udiv.lean
|
theorem denote_blastUdiv (aig : AIG α) (lhs rhs : BitVec w) (assign : α → Bool)
(input : BinaryRefVec aig w)
(hleft : ∀ (idx : Nat) (hidx : idx < w), ⟦aig, input.lhs.get idx hidx, assign⟧ = lhs.getLsbD idx)
(hright : ∀ (idx : Nat) (hidx : idx < w), ⟦aig, input.rhs.get idx hidx, assign⟧ = rhs.getLsbD idx) :
∀ (idx : Nat) (hidx : idx < w),
⟦(blastUdiv aig input).aig, (blastUdiv aig input).vec.get idx hidx, assign⟧
=
(lhs / rhs).getLsbD idx
|
case htrue
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
lhs rhs : BitVec w
assign : α → Bool
input : aig.BinaryRefVec w
hleft : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := input.lhs.get idx hidx }⟧ = lhs.getLsbD idx
hright : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := input.rhs.get idx hidx }⟧ = rhs.getLsbD idx
idx : Nat
hidx : idx < w
hdiscr✝ :
¬⟦assign,
{
aig :=
(blastUdiv.go
(BVPred.mkEq (((blastConst aig 0#w).aig.mkConstCached false).aig.mkConstCached true).aig
{ lhs := (((input.cast ⋯).cast ⋯).cast ⋯).rhs,
rhs := ((blastConst aig 0#w).vec.cast ⋯).cast ⋯ }).aig
w { gate := ((blastConst aig 0#w).aig.mkConstCached false).ref.gate, hgate := ⋯ }
{ gate := (((blastConst aig 0#w).aig.mkConstCached false).aig.mkConstCached true).ref.gate, hgate := ⋯ }
((((input.cast ⋯).cast ⋯).cast ⋯).lhs.cast ⋯) ((((input.cast ⋯).cast ⋯).cast ⋯).rhs.cast ⋯) w 0
((((blastConst aig 0#w).vec.cast ⋯).cast ⋯).cast ⋯)
((((blastConst aig 0#w).vec.cast ⋯).cast ⋯).cast ⋯)).aig,
ref :=
{
gate :=
(BVPred.mkEq (((blastConst aig 0#w).aig.mkConstCached false).aig.mkConstCached true).aig
{ lhs := (((input.cast ⋯).cast ⋯).cast ⋯).rhs,
rhs := ((blastConst aig 0#w).vec.cast ⋯).cast ⋯ }).ref.gate,
hgate := ⋯ } }⟧ =
true
hdiscr : ¬(rhs == 0#w) = true
hzero : 0#w < rhs
⊢ ⟦assign,
{
aig :=
(BVPred.mkEq (((blastConst aig 0#w).aig.mkConstCached false).aig.mkConstCached true).aig
{ lhs := (((input.cast ⋯).cast ⋯).cast ⋯).rhs, rhs := ((blastConst aig 0#w).vec.cast ⋯).cast ⋯ }).aig,
ref :=
{ gate := (((blastConst aig 0#w).aig.mkConstCached false).aig.mkConstCached true).ref.gate, hgate := ⋯ } }⟧ =
true
|
rw [AIG.LawfulOperator.denote_mem_prefix (f := BVPred.mkEq)]
|
case htrue
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
lhs rhs : BitVec w
assign : α → Bool
input : aig.BinaryRefVec w
hleft : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := input.lhs.get idx hidx }⟧ = lhs.getLsbD idx
hright : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := input.rhs.get idx hidx }⟧ = rhs.getLsbD idx
idx : Nat
hidx : idx < w
hdiscr✝ :
¬⟦assign,
{
aig :=
(blastUdiv.go
(BVPred.mkEq (((blastConst aig 0#w).aig.mkConstCached false).aig.mkConstCached true).aig
{ lhs := (((input.cast ⋯).cast ⋯).cast ⋯).rhs,
rhs := ((blastConst aig 0#w).vec.cast ⋯).cast ⋯ }).aig
w { gate := ((blastConst aig 0#w).aig.mkConstCached false).ref.gate, hgate := ⋯ }
{ gate := (((blastConst aig 0#w).aig.mkConstCached false).aig.mkConstCached true).ref.gate, hgate := ⋯ }
((((input.cast ⋯).cast ⋯).cast ⋯).lhs.cast ⋯) ((((input.cast ⋯).cast ⋯).cast ⋯).rhs.cast ⋯) w 0
((((blastConst aig 0#w).vec.cast ⋯).cast ⋯).cast ⋯)
((((blastConst aig 0#w).vec.cast ⋯).cast ⋯).cast ⋯)).aig,
ref :=
{
gate :=
(BVPred.mkEq (((blastConst aig 0#w).aig.mkConstCached false).aig.mkConstCached true).aig
{ lhs := (((input.cast ⋯).cast ⋯).cast ⋯).rhs,
rhs := ((blastConst aig 0#w).vec.cast ⋯).cast ⋯ }).ref.gate,
hgate := ⋯ } }⟧ =
true
hdiscr : ¬(rhs == 0#w) = true
hzero : 0#w < rhs
⊢ ⟦assign,
{ aig := (((blastConst aig 0#w).aig.mkConstCached false).aig.mkConstCached true).aig,
ref :=
{ gate := (((blastConst aig 0#w).aig.mkConstCached false).aig.mkConstCached true).ref.gate,
hgate := ?htrue } }⟧ =
true
case htrue
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
lhs rhs : BitVec w
assign : α → Bool
input : aig.BinaryRefVec w
hleft : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := input.lhs.get idx hidx }⟧ = lhs.getLsbD idx
hright : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := input.rhs.get idx hidx }⟧ = rhs.getLsbD idx
idx : Nat
hidx : idx < w
hdiscr✝ :
¬⟦assign,
{
aig :=
(blastUdiv.go
(BVPred.mkEq (((blastConst aig 0#w).aig.mkConstCached false).aig.mkConstCached true).aig
{ lhs := (((input.cast ⋯).cast ⋯).cast ⋯).rhs,
rhs := ((blastConst aig 0#w).vec.cast ⋯).cast ⋯ }).aig
w { gate := ((blastConst aig 0#w).aig.mkConstCached false).ref.gate, hgate := ⋯ }
{ gate := (((blastConst aig 0#w).aig.mkConstCached false).aig.mkConstCached true).ref.gate, hgate := ⋯ }
((((input.cast ⋯).cast ⋯).cast ⋯).lhs.cast ⋯) ((((input.cast ⋯).cast ⋯).cast ⋯).rhs.cast ⋯) w 0
((((blastConst aig 0#w).vec.cast ⋯).cast ⋯).cast ⋯)
((((blastConst aig 0#w).vec.cast ⋯).cast ⋯).cast ⋯)).aig,
ref :=
{
gate :=
(BVPred.mkEq (((blastConst aig 0#w).aig.mkConstCached false).aig.mkConstCached true).aig
{ lhs := (((input.cast ⋯).cast ⋯).cast ⋯).rhs,
rhs := ((blastConst aig 0#w).vec.cast ⋯).cast ⋯ }).ref.gate,
hgate := ⋯ } }⟧ =
true
hdiscr : ¬(rhs == 0#w) = true
hzero : 0#w < rhs
⊢ (((blastConst aig 0#w).aig.mkConstCached false).aig.mkConstCached true).ref.gate <
(((blastConst aig 0#w).aig.mkConstCached false).aig.mkConstCached true).aig.decls.size
|
1e06923b53c4a62f
|
CategoryTheory.Abelian.epiWithInjectiveKernel_iff
|
Mathlib/CategoryTheory/Abelian/EpiWithInjectiveKernel.lean
|
/-- A morphism `g : X ⟶ Y` is epi with an injective kernel iff there exists a morphism
`f : I ⟶ X` with `I` injective such that `f ≫ g = 0` and
the short complex `I ⟶ X ⟶ Y` has a splitting. -/
lemma epiWithInjectiveKernel_iff {X Y : C} (g : X ⟶ Y) :
epiWithInjectiveKernel g ↔ ∃ (I : C) (_ : Injective I) (f : I ⟶ X) (w : f ≫ g = 0),
Nonempty (ShortComplex.mk f g w).Splitting
|
case mpr.intro.intro.intro.intro.intro
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
g : X ⟶ Y
I : C
w✝ : Injective I
f : I ⟶ X
w : f ≫ g = 0
σ : (ShortComplex.mk f g w).Splitting
this : IsSplitEpi g
e : I ≅ kernel g := ⋯.fIsKernel.conePointUniqueUpToIso (limit.isLimit (parallelPair (ShortComplex.mk f g w).g 0))
⊢ epiWithInjectiveKernel g
|
exact ⟨inferInstance, Injective.of_iso e inferInstance⟩
|
no goals
|
0c2777975f72cb4f
|
RootPairing.Base.eq_one_or_neg_one_of_mem_support_of_smul_mem
|
Mathlib/LinearAlgebra/RootSystem/Base.lean
|
lemma eq_one_or_neg_one_of_mem_support_of_smul_mem [Finite ι] [CharZero R]
[NoZeroSMulDivisors ℤ M] [NoZeroSMulDivisors ℤ N]
(i : ι) (h : i ∈ b.support) (t : R) (ht : t • P.root i ∈ range P.root) :
t = 1 ∨ t = - 1
|
case intro.intro.intro
ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : RootPairing ι R M N
b : P.Base
inst✝³ : Finite ι
inst✝² : CharZero R
inst✝¹ : NoZeroSMulDivisors ℤ M
inst✝ : NoZeroSMulDivisors ℤ N
i : ι
h : i ∈ b.support
t : R
z : ℤ
hz : ↑z * t = 1
s : R
hs : s * t = 1
ht : s • P.coroot i ∈ range ⇑P.coroot
w : ℤ
hw : ↑w * s = 1
this : ↑z * ↑w = 1
⊢ z = 1 ∨ z = -1
|
norm_cast at this
|
case intro.intro.intro
ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : RootPairing ι R M N
b : P.Base
inst✝³ : Finite ι
inst✝² : CharZero R
inst✝¹ : NoZeroSMulDivisors ℤ M
inst✝ : NoZeroSMulDivisors ℤ N
i : ι
h : i ∈ b.support
t : R
z : ℤ
hz : ↑z * t = 1
s : R
hs : s * t = 1
ht : s • P.coroot i ∈ range ⇑P.coroot
w : ℤ
hw : ↑w * s = 1
this : z * w = 1
⊢ z = 1 ∨ z = -1
|
439980ec01794b6b
|
AlgebraNorm.extends_norm
|
Mathlib/Analysis/Normed/Algebra/Norm.lean
|
theorem extends_norm (hf1 : f 1 = 1) (a : R) : f (algebraMap R S a) = ‖a‖
|
R : Type u_1
inst✝² : SeminormedCommRing R
S : Type u_2
inst✝¹ : Ring S
inst✝ : Algebra R S
f : AlgebraNorm R S
hf1 : f 1 = 1
a : R
⊢ f ((algebraMap R S) a) = ‖a‖
|
rw [Algebra.algebraMap_eq_smul_one]
|
R : Type u_1
inst✝² : SeminormedCommRing R
S : Type u_2
inst✝¹ : Ring S
inst✝ : Algebra R S
f : AlgebraNorm R S
hf1 : f 1 = 1
a : R
⊢ f (a • 1) = ‖a‖
|
431c6dca7cb059de
|
Complex.convexHull_reProdIm
|
Mathlib/Analysis/Complex/Convex.lean
|
/-- A version of `convexHull_prod` for `Set.reProdIm`. -/
lemma convexHull_reProdIm (s t : Set ℝ) :
convexHull ℝ (s ×ℂ t) = convexHull ℝ s ×ℂ convexHull ℝ t :=
calc
convexHull ℝ (equivRealProdLm ⁻¹' (s ×ˢ t)) = equivRealProdLm ⁻¹' convexHull ℝ (s ×ˢ t)
|
s t : Set ℝ
⊢ ⇑equivRealProdLm ⁻¹' (convexHull ℝ) s ×ˢ (convexHull ℝ) t = (convexHull ℝ) s ×ℂ (convexHull ℝ) t
|
rfl
|
no goals
|
592c11d91a158a4b
|
CantorScheme.ClosureAntitone.map_of_vanishingDiam
|
Mathlib/Topology/MetricSpace/CantorScheme.lean
|
theorem ClosureAntitone.map_of_vanishingDiam [CompleteSpace α] (hdiam : VanishingDiam A)
(hanti : ClosureAntitone A) (hnonempty : ∀ l, (A l).Nonempty) : (inducedMap A).1 = univ
|
β : Type u_1
α : Type u_2
A : List β → Set α
inst✝¹ : PseudoMetricSpace α
inst✝ : CompleteSpace α
hdiam : VanishingDiam A
hanti : ClosureAntitone A
hnonempty : ∀ (l : List β), (A l).Nonempty
x : ℕ → β
u : ℕ → α
hu : ∀ (n : ℕ), u n ∈ A (res x n)
⊢ x ∈ (inducedMap A).fst
|
have umem : ∀ n m : ℕ, n ≤ m → u m ∈ A (res x n) := by
have : Antitone fun n : ℕ => A (res x n) := by
refine antitone_nat_of_succ_le ?_
intro n
apply hanti.antitone
intro n m hnm
exact this hnm (hu _)
|
β : Type u_1
α : Type u_2
A : List β → Set α
inst✝¹ : PseudoMetricSpace α
inst✝ : CompleteSpace α
hdiam : VanishingDiam A
hanti : ClosureAntitone A
hnonempty : ∀ (l : List β), (A l).Nonempty
x : ℕ → β
u : ℕ → α
hu : ∀ (n : ℕ), u n ∈ A (res x n)
umem : ∀ (n m : ℕ), n ≤ m → u m ∈ A (res x n)
⊢ x ∈ (inducedMap A).fst
|
84475af12dd43d16
|
Ideal.finsuppTotal_apply_eq_of_fintype
|
Mathlib/RingTheory/Ideal/Operations.lean
|
theorem finsuppTotal_apply_eq_of_fintype [Fintype ι] (f : ι →₀ I) :
finsuppTotal ι M I v f = ∑ i, (f i : R) • v i
|
case h
ι : Type u_1
M : Type u_2
inst✝³ : AddCommGroup M
R : Type u_3
inst✝² : CommRing R
inst✝¹ : Module R M
I : Ideal R
v : ι → M
inst✝ : Fintype ι
f : ι →₀ ↥I
⊢ ∀ (i : ι), ↑0 • v i = 0
|
exact fun _ => zero_smul _ _
|
no goals
|
b52934c6ae1d2ce2
|
MeasureTheory.integrableOn_image_iff_integrableOn_abs_deriv_smul
|
Mathlib/MeasureTheory/Function/Jacobian.lean
|
theorem integrableOn_image_iff_integrableOn_abs_deriv_smul {s : Set ℝ} {f : ℝ → ℝ} {f' : ℝ → ℝ}
(hs : MeasurableSet s) (hf' : ∀ x ∈ s, HasDerivWithinAt f (f' x) s x) (hf : InjOn f s)
(g : ℝ → F) : IntegrableOn g (f '' s) ↔ IntegrableOn (fun x => |f' x| • g (f x)) s
|
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
s : Set ℝ
f f' : ℝ → ℝ
hs : MeasurableSet s
hf' : ∀ x ∈ s, HasDerivWithinAt f (f' x) s x
hf : InjOn f s
g : ℝ → F
⊢ IntegrableOn g (f '' s) volume ↔ IntegrableOn (fun x => |f' x| • g (f x)) s volume
|
simpa only [det_one_smulRight] using
integrableOn_image_iff_integrableOn_abs_det_fderiv_smul volume hs
(fun x hx => (hf' x hx).hasFDerivWithinAt) hf g
|
no goals
|
cfe539c64d05a471
|
AffineMap.pi_ext_zero
|
Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
|
theorem pi_ext_zero (h : ∀ i x, f (Pi.single i x) = g (Pi.single i x)) (h₂ : f 0 = g 0) :
f = g
|
case h₁.h
k : Type u_2
V2 : Type u_5
P2 : Type u_6
inst✝⁷ : Ring k
inst✝⁶ : AddCommGroup V2
inst✝⁵ : AffineSpace V2 P2
inst✝⁴ : Module k V2
ι : Type u_9
φv : ι → Type u_10
inst✝³ : (i : ι) → AddCommGroup (φv i)
inst✝² : (i : ι) → Module k (φv i)
inst✝¹ : Finite ι
inst✝ : DecidableEq ι
f g : ((i : ι) → φv i) →ᵃ[k] P2
h : ∀ (i : ι) (x : φv i), f (Pi.single i x) = g (Pi.single i x)
h₂ : f 0 = g 0
i : ι
x : φv i
s₁ : f (Pi.single i x) = g (Pi.single i x)
s₂ : f (Pi.single i x +ᵥ 0) = f.linear (Pi.single i x) +ᵥ f 0
s₃ : g (Pi.single i x +ᵥ 0) = g.linear (Pi.single i x) +ᵥ g 0
⊢ f.linear (Pi.single i x) = g.linear (Pi.single i x)
|
rw [vadd_eq_add, add_zero] at s₂ s₃
|
case h₁.h
k : Type u_2
V2 : Type u_5
P2 : Type u_6
inst✝⁷ : Ring k
inst✝⁶ : AddCommGroup V2
inst✝⁵ : AffineSpace V2 P2
inst✝⁴ : Module k V2
ι : Type u_9
φv : ι → Type u_10
inst✝³ : (i : ι) → AddCommGroup (φv i)
inst✝² : (i : ι) → Module k (φv i)
inst✝¹ : Finite ι
inst✝ : DecidableEq ι
f g : ((i : ι) → φv i) →ᵃ[k] P2
h : ∀ (i : ι) (x : φv i), f (Pi.single i x) = g (Pi.single i x)
h₂ : f 0 = g 0
i : ι
x : φv i
s₁ : f (Pi.single i x) = g (Pi.single i x)
s₂ : f (Pi.single i x) = f.linear (Pi.single i x) +ᵥ f 0
s₃ : g (Pi.single i x) = g.linear (Pi.single i x) +ᵥ g 0
⊢ f.linear (Pi.single i x) = g.linear (Pi.single i x)
|
f4a501a2d9ab4d4a
|
Turing.TM2to1.tr_respects_aux
|
Mathlib/Computability/TuringMachine.lean
|
theorem tr_respects_aux {q v T k} {S : ∀ k, List (Γ k)}
(hT : ∀ k, ListBlank.map (proj k) T = ListBlank.mk ((S k).map some).reverse)
(o : StAct K Γ σ k)
(IH : ∀ {v : σ} {S : ∀ k : K, List (Γ k)} {T : ListBlank (∀ k, Option (Γ k))},
(∀ k, ListBlank.map (proj k) T = ListBlank.mk ((S k).map some).reverse) →
∃ b, TrCfg (TM2.stepAux q v S) b ∧
Reaches (TM1.step (tr M)) (TM1.stepAux (trNormal q) v (Tape.mk' ∅ (addBottom T))) b) :
∃ b, TrCfg (TM2.stepAux (stRun o q) v S) b ∧ Reaches (TM1.step (tr M))
(TM1.stepAux (trNormal (stRun o q)) v (Tape.mk' ∅ (addBottom T))) b
|
K : Type u_1
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
inst✝ : DecidableEq K
M : Λ → TM2.Stmt Γ Λ σ
q : TM2.Stmt Γ Λ σ
v : σ
T : ListBlank ((i : K) → Option (Γ i))
k : K
S : (k : K) → List (Γ k)
hT : ∀ (k : K), ListBlank.map (proj k) T = ListBlank.mk (List.map some (S k)).reverse
o : StAct K Γ σ k
IH :
∀ {v : σ} {S : (k : K) → List (Γ k)} {T : ListBlank ((k : K) → Option (Γ k))},
(∀ (k : K), ListBlank.map (proj k) T = ListBlank.mk (List.map some (S k)).reverse) →
∃ b,
TrCfg (TM2.stepAux q v S) b ∧
Reaches (TM1.step (tr M)) (TM1.stepAux (trNormal q) v (Tape.mk' ∅ (addBottom T))) b
hgo :
Reaches₀ (TM1.step (tr M)) { l := some (go k o q), var := v, Tape := Tape.mk' ∅ (addBottom T) }
{ l := some (go k o q), var := v, Tape := (Tape.move Dir.right)^[(S k).length] (Tape.mk' ∅ (addBottom T)) }
⊢ ∃ b,
TrCfg (TM2.stepAux q (stVar v (S k) o) (update S k (stWrite v (S k) o))) b ∧
Reaches (TM1.step (tr M)) (TM1.stepAux (goto fun x x => go k o q) v (Tape.mk' ∅ (addBottom T))) b
|
obtain ⟨T', hT', hrun⟩ := tr_respects_aux₂ (Λ := Λ) hT o
|
case intro.intro
K : Type u_1
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
inst✝ : DecidableEq K
M : Λ → TM2.Stmt Γ Λ σ
q : TM2.Stmt Γ Λ σ
v : σ
T : ListBlank ((i : K) → Option (Γ i))
k : K
S : (k : K) → List (Γ k)
hT : ∀ (k : K), ListBlank.map (proj k) T = ListBlank.mk (List.map some (S k)).reverse
o : StAct K Γ σ k
IH :
∀ {v : σ} {S : (k : K) → List (Γ k)} {T : ListBlank ((k : K) → Option (Γ k))},
(∀ (k : K), ListBlank.map (proj k) T = ListBlank.mk (List.map some (S k)).reverse) →
∃ b,
TrCfg (TM2.stepAux q v S) b ∧
Reaches (TM1.step (tr M)) (TM1.stepAux (trNormal q) v (Tape.mk' ∅ (addBottom T))) b
hgo :
Reaches₀ (TM1.step (tr M)) { l := some (go k o q), var := v, Tape := Tape.mk' ∅ (addBottom T) }
{ l := some (go k o q), var := v, Tape := (Tape.move Dir.right)^[(S k).length] (Tape.mk' ∅ (addBottom T)) }
T' : ListBlank ((k : K) → Option (Γ k))
hT' :
∀ (k_1 : K),
ListBlank.map (proj k_1) T' = ListBlank.mk (List.map some (update S k (stWrite ?m.137053 (S k) o) k_1)).reverse
hrun :
TM1.stepAux (trStAct ?m.137052 o) ?m.137053 ((Tape.move Dir.right)^[(S k).length] (Tape.mk' ∅ (addBottom T))) =
TM1.stepAux ?m.137052 (stVar ?m.137053 (S k) o)
((Tape.move Dir.right)^[(update S k (stWrite ?m.137053 (S k) o) k).length] (Tape.mk' ∅ (addBottom T')))
⊢ ∃ b,
TrCfg (TM2.stepAux q (stVar v (S k) o) (update S k (stWrite v (S k) o))) b ∧
Reaches (TM1.step (tr M)) (TM1.stepAux (goto fun x x => go k o q) v (Tape.mk' ∅ (addBottom T))) b
|
87971184416ca292
|
SimpleGraph.deleteEdges_edgeSet
|
Mathlib/Combinatorics/SimpleGraph/Basic.lean
|
@[simp] lemma deleteEdges_edgeSet (G G' : SimpleGraph V) : G.deleteEdges G'.edgeSet = G \ G'
|
case Adj.h.h.a
V : Type u
G G' : SimpleGraph V
x✝¹ x✝ : V
⊢ (G.deleteEdges G'.edgeSet).Adj x✝¹ x✝ ↔ (G \ G').Adj x✝¹ x✝
|
simp
|
no goals
|
01becce2541a1a09
|
image_subset_closure_compl_image_compl_of_isOpen
|
Mathlib/Topology/ExtremallyDisconnected.lean
|
/-- Lemma 2.1 in [Gleason, *Projective topological spaces*][gleason1958]:
if $\rho$ is a continuous surjection from a topological space $E$ to a topological space $A$
satisfying the "Zorn subset condition", then $\rho(G)$ is contained in
the closure of $A \setminus \rho(E \setminus G)$ for any open set $G$ of $E$. -/
lemma image_subset_closure_compl_image_compl_of_isOpen {ρ : E → A} (ρ_cont : Continuous ρ)
(ρ_surj : ρ.Surjective) (zorn_subset : ∀ E₀ : Set E, E₀ ≠ univ → IsClosed E₀ → ρ '' E₀ ≠ univ)
{G : Set E} (hG : IsOpen G) : ρ '' G ⊆ closure ((ρ '' Gᶜ)ᶜ)
|
case neg.intro.intro
A E : Type u
inst✝¹ : TopologicalSpace A
inst✝ : TopologicalSpace E
ρ : E → A
ρ_cont : Continuous ρ
ρ_surj : Surjective ρ
zorn_subset : ∀ (E₀ : Set E), E₀ ≠ univ → IsClosed E₀ → ρ '' E₀ ≠ univ
G : Set E
hG : IsOpen G
G_empty : ¬G = ∅
N : Set A
N_open : IsOpen N
e : E
he : e ∈ G
ha : ρ e ∈ ρ '' G
hN : ρ e ∈ N
⊢ (N ∩ (ρ '' Gᶜ)ᶜ).Nonempty
|
have nonempty : (G ∩ ρ⁻¹' N).Nonempty := ⟨e, mem_inter he <| mem_preimage.mpr hN⟩
|
case neg.intro.intro
A E : Type u
inst✝¹ : TopologicalSpace A
inst✝ : TopologicalSpace E
ρ : E → A
ρ_cont : Continuous ρ
ρ_surj : Surjective ρ
zorn_subset : ∀ (E₀ : Set E), E₀ ≠ univ → IsClosed E₀ → ρ '' E₀ ≠ univ
G : Set E
hG : IsOpen G
G_empty : ¬G = ∅
N : Set A
N_open : IsOpen N
e : E
he : e ∈ G
ha : ρ e ∈ ρ '' G
hN : ρ e ∈ N
nonempty : (G ∩ ρ ⁻¹' N).Nonempty
⊢ (N ∩ (ρ '' Gᶜ)ᶜ).Nonempty
|
7e7582b54cb8739a
|
ruzsaSzemerediNumberNat_asymptotic_lower_bound
|
Mathlib/Combinatorics/Extremal/RuzsaSzemeredi.lean
|
theorem ruzsaSzemerediNumberNat_asymptotic_lower_bound :
(fun n ↦ n ^ 2 * exp (-4 * sqrt (log n)) : ℕ → ℝ) =O[atTop]
fun n ↦ (ruzsaSzemerediNumberNat n : ℝ)
|
x : ℕ
hx : x ≥ 15
⊢ ↑x ≤ 12 * ↑((x - 3) / 6)
|
norm_cast
|
x : ℕ
hx : x ≥ 15
⊢ x ≤ 12 * ((x - 3) / 6)
|
72990b3a12cc99c5
|
LieSubmodule.lieIdeal_oper_eq_linear_span'
|
Mathlib/Algebra/Lie/IdealOperations.lean
|
theorem lieIdeal_oper_eq_linear_span' [LieModule R L M] :
(↑⁅I, N⁆ : Submodule R M) = Submodule.span R { ⁅x, n⁆ | (x ∈ I) (n ∈ N) }
|
case e_s.h.mpr
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
N : LieSubmodule R L M
inst✝¹ : LieAlgebra R L
I : LieIdeal R L
inst✝ : LieModule R L M
m : M
⊢ m ∈ {x | ∃ x_1 ∈ I, ∃ n ∈ N, ⁅x_1, n⁆ = x} → m ∈ {x | ∃ x_1 n, ⁅↑x_1, ↑n⁆ = x}
|
rintro ⟨x, hx, n, hn, rfl⟩
|
case e_s.h.mpr.intro.intro.intro.intro
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
N : LieSubmodule R L M
inst✝¹ : LieAlgebra R L
I : LieIdeal R L
inst✝ : LieModule R L M
x : L
hx : x ∈ I
n : M
hn : n ∈ N
⊢ ⁅x, n⁆ ∈ {x | ∃ x_1 n, ⁅↑x_1, ↑n⁆ = x}
|
36507cbeea573138
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.insertUnitInvariant_insertUnit
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.lean
|
theorem insertUnitInvariant_insertUnit {n : Nat} (assignments0 : Array Assignment)
(assignments0_size : assignments0.size = n) (units : Array (Literal (PosFin n)))
(assignments : Array Assignment) (assignments_size : assignments.size = n)
(foundContradiction : Bool) (l : Literal (PosFin n)) :
InsertUnitInvariant assignments0 assignments0_size units assignments assignments_size →
let update_res := insertUnit (units, assignments, foundContradiction) l
have update_res_size : update_res.snd.fst.size = n
|
case neg
n : Nat
assignments0 : Array Assignment
assignments0_size : assignments0.size = n
units : Array (Literal (PosFin n))
assignments : Array Assignment
assignments_size : assignments.size = n
foundContradiction : Bool
l : Literal (PosFin n)
i : Fin n
i_in_bounds : ↑i < assignments.size
l_in_bounds : l.fst.val < assignments.size
j : Fin units.size
b : Bool
i_gt_zero : ↑i > 0
h4 : ∀ (k : Fin units.size), ¬k = j → ¬units[↑k].fst.val = ↑i
h5 : ¬hasAssignment l.snd assignments[l.fst.val]! = true
i_eq_l : ↑i = l.fst.val
units_size_lt_updatedUnits_size : units.size < (insertUnit (units, assignments, foundContradiction) l).fst.size
mostRecentUnitIdx : Fin (insertUnit (units, assignments, foundContradiction) l).fst.size :=
⟨units.size, units_size_lt_updatedUnits_size⟩
j_lt_updatedUnits_size : ↑j < (insertUnit (units, assignments, foundContradiction) l).fst.size
h1 : units[↑j] = (⟨↑i, ⋯⟩, true)
h2 : assignments[↑i] = addAssignment true assignments0[↑i]
h3 : hasAssignment true assignments0[↑i] = false
hb : b = true
hl : l.snd = false
k :
Fin
(if hasAssignment l.snd assignments[l.fst.val]! = true then (units, assignments, foundContradiction)
else
(units.push (l.fst, l.snd), assignments.modify l.fst.val (addAssignment l.snd),
foundContradiction || assignments[l.fst.val]! != unassigned)).fst.size
k_ne_j : ¬k = ⟨↑j, j_lt_updatedUnits_size⟩
k_ne_l : ¬k = mostRecentUnitIdx
h : ¬↑k < units.size
⊢ ¬(if h : ↑k < units.size then units[↑k] else (l.fst, l.snd)).fst.val = ↑i
|
exfalso
|
case neg
n : Nat
assignments0 : Array Assignment
assignments0_size : assignments0.size = n
units : Array (Literal (PosFin n))
assignments : Array Assignment
assignments_size : assignments.size = n
foundContradiction : Bool
l : Literal (PosFin n)
i : Fin n
i_in_bounds : ↑i < assignments.size
l_in_bounds : l.fst.val < assignments.size
j : Fin units.size
b : Bool
i_gt_zero : ↑i > 0
h4 : ∀ (k : Fin units.size), ¬k = j → ¬units[↑k].fst.val = ↑i
h5 : ¬hasAssignment l.snd assignments[l.fst.val]! = true
i_eq_l : ↑i = l.fst.val
units_size_lt_updatedUnits_size : units.size < (insertUnit (units, assignments, foundContradiction) l).fst.size
mostRecentUnitIdx : Fin (insertUnit (units, assignments, foundContradiction) l).fst.size :=
⟨units.size, units_size_lt_updatedUnits_size⟩
j_lt_updatedUnits_size : ↑j < (insertUnit (units, assignments, foundContradiction) l).fst.size
h1 : units[↑j] = (⟨↑i, ⋯⟩, true)
h2 : assignments[↑i] = addAssignment true assignments0[↑i]
h3 : hasAssignment true assignments0[↑i] = false
hb : b = true
hl : l.snd = false
k :
Fin
(if hasAssignment l.snd assignments[l.fst.val]! = true then (units, assignments, foundContradiction)
else
(units.push (l.fst, l.snd), assignments.modify l.fst.val (addAssignment l.snd),
foundContradiction || assignments[l.fst.val]! != unassigned)).fst.size
k_ne_j : ¬k = ⟨↑j, j_lt_updatedUnits_size⟩
k_ne_l : ¬k = mostRecentUnitIdx
h : ¬↑k < units.size
⊢ False
|
4e9908103f3f6d5f
|
Polynomial.reflect_mul_induction
|
Mathlib/Algebra/Polynomial/Reverse.lean
|
theorem reflect_mul_induction (cf cg : ℕ) :
∀ N O : ℕ,
∀ f g : R[X],
#f.support ≤ cf.succ →
#g.support ≤ cg.succ →
f.natDegree ≤ N →
g.natDegree ≤ O → reflect (N + O) (f * g) = reflect N f * reflect O g
|
R : Type u_1
inst✝ : Semiring R
cf cg : ℕ
⊢ ∀ (N O : ℕ) (f g : R[X]),
#f.support ≤ cf.succ →
#g.support ≤ cg.succ → f.natDegree ≤ N → g.natDegree ≤ O → reflect (N + O) (f * g) = reflect N f * reflect O g
|
induction' cf with cf hcf
|
case zero
R : Type u_1
inst✝ : Semiring R
cg : ℕ
⊢ ∀ (N O : ℕ) (f g : R[X]),
#f.support ≤ Nat.succ 0 →
#g.support ≤ cg.succ → f.natDegree ≤ N → g.natDegree ≤ O → reflect (N + O) (f * g) = reflect N f * reflect O g
case succ
R : Type u_1
inst✝ : Semiring R
cg cf : ℕ
hcf :
∀ (N O : ℕ) (f g : R[X]),
#f.support ≤ cf.succ →
#g.support ≤ cg.succ → f.natDegree ≤ N → g.natDegree ≤ O → reflect (N + O) (f * g) = reflect N f * reflect O g
⊢ ∀ (N O : ℕ) (f g : R[X]),
#f.support ≤ (cf + 1).succ →
#g.support ≤ cg.succ → f.natDegree ≤ N → g.natDegree ≤ O → reflect (N + O) (f * g) = reflect N f * reflect O g
|
0a2af005637b9810
|
Vitali.exists_disjoint_covering_ae
|
Mathlib/MeasureTheory/Covering/Vitali.lean
|
theorem exists_disjoint_covering_ae
[PseudoMetricSpace α] [MeasurableSpace α] [OpensMeasurableSpace α]
[SecondCountableTopology α] (μ : Measure α) [IsLocallyFiniteMeasure μ] (s : Set α) (t : Set ι)
(C : ℝ≥0) (r : ι → ℝ) (c : ι → α) (B : ι → Set α) (hB : ∀ a ∈ t, B a ⊆ closedBall (c a) (r a))
(μB : ∀ a ∈ t, μ (closedBall (c a) (3 * r a)) ≤ C * μ (B a))
(ht : ∀ a ∈ t, (interior (B a)).Nonempty) (h't : ∀ a ∈ t, IsClosed (B a))
(hf : ∀ x ∈ s, ∀ ε > (0 : ℝ), ∃ a ∈ t, r a ≤ ε ∧ c a = x) :
∃ u ⊆ t, u.Countable ∧ u.PairwiseDisjoint B ∧ μ (s \ ⋃ a ∈ u, B a) = 0
|
α : Type u_1
ι : Type u_2
inst✝⁴ : PseudoMetricSpace α
inst✝³ : MeasurableSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : SecondCountableTopology α
μ : Measure α
inst✝ : IsLocallyFiniteMeasure μ
s : Set α
t : Set ι
C : ℝ≥0
r : ι → ℝ
c : ι → α
B : ι → Set α
hB : ∀ a ∈ t, B a ⊆ closedBall (c a) (r a)
μB : ∀ a ∈ t, μ (closedBall (c a) (3 * r a)) ≤ ↑C * μ (B a)
ht : ∀ a ∈ t, (interior (B a)).Nonempty
h't : ∀ a ∈ t, IsClosed (B a)
hf : ∀ x ∈ s, ∀ ε > 0, ∃ a ∈ t, r a ≤ ε ∧ c a = x
R : α → ℝ
hR0 : ∀ (x : α), 0 < R x
hR1 : ∀ (x : α), R x ≤ 1
hRμ : ∀ (x : α), μ (closedBall x (20 * R x)) < ⊤
t' : Set ι := {a | a ∈ t ∧ r a ≤ R (c a)}
u : Set ι
ut' : u ⊆ t'
u_disj : u.PairwiseDisjoint B
hu : ∀ a ∈ t', ∃ b ∈ u, (B a ∩ B b).Nonempty ∧ r a ≤ 2 * r b
ut : u ⊆ t
u_count : u.Countable
x : α
x✝ : x ∈ s \ ⋃ a ∈ u, B a
v : Set ι := {a | a ∈ u ∧ (B a ∩ ball x (R x)).Nonempty}
vu : v ⊆ u
Idist_v : ∀ a ∈ v, dist (c a) x ≤ r a + R x
R0 : ℝ := sSup (r '' v)
R0_def : R0 = sSup (r '' v)
⊢ BddAbove (r '' v)
|
refine ⟨1, fun r' hr' => ?_⟩
|
α : Type u_1
ι : Type u_2
inst✝⁴ : PseudoMetricSpace α
inst✝³ : MeasurableSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : SecondCountableTopology α
μ : Measure α
inst✝ : IsLocallyFiniteMeasure μ
s : Set α
t : Set ι
C : ℝ≥0
r : ι → ℝ
c : ι → α
B : ι → Set α
hB : ∀ a ∈ t, B a ⊆ closedBall (c a) (r a)
μB : ∀ a ∈ t, μ (closedBall (c a) (3 * r a)) ≤ ↑C * μ (B a)
ht : ∀ a ∈ t, (interior (B a)).Nonempty
h't : ∀ a ∈ t, IsClosed (B a)
hf : ∀ x ∈ s, ∀ ε > 0, ∃ a ∈ t, r a ≤ ε ∧ c a = x
R : α → ℝ
hR0 : ∀ (x : α), 0 < R x
hR1 : ∀ (x : α), R x ≤ 1
hRμ : ∀ (x : α), μ (closedBall x (20 * R x)) < ⊤
t' : Set ι := {a | a ∈ t ∧ r a ≤ R (c a)}
u : Set ι
ut' : u ⊆ t'
u_disj : u.PairwiseDisjoint B
hu : ∀ a ∈ t', ∃ b ∈ u, (B a ∩ B b).Nonempty ∧ r a ≤ 2 * r b
ut : u ⊆ t
u_count : u.Countable
x : α
x✝ : x ∈ s \ ⋃ a ∈ u, B a
v : Set ι := {a | a ∈ u ∧ (B a ∩ ball x (R x)).Nonempty}
vu : v ⊆ u
Idist_v : ∀ a ∈ v, dist (c a) x ≤ r a + R x
R0 : ℝ := sSup (r '' v)
R0_def : R0 = sSup (r '' v)
r' : ℝ
hr' : r' ∈ r '' v
⊢ r' ≤ 1
|
4466d2fc3e80cb3f
|
CharTwo.of_one_ne_zero_of_two_eq_zero
|
Mathlib/Algebra/CharP/Two.lean
|
theorem of_one_ne_zero_of_two_eq_zero (h₁ : (1 : R) ≠ 0) (h₂ : (2 : R) = 0) : CharP R 2 where
cast_eq_zero_iff' n
|
case inr
R : Type u_1
inst✝ : AddMonoidWithOne R
h₁ : 1 ≠ 0
h₂ : 2 = 0
n : ℕ
hn : Odd n
⊢ ¬↑n = 0
|
rwa [natCast_eq_one_of_odd_of_two_eq_zero hn h₂]
|
no goals
|
64f3abafce47a6cd
|
MvPolynomial.degrees_rename
|
Mathlib/Algebra/MvPolynomial/Degrees.lean
|
theorem degrees_rename (f : σ → τ) (φ : MvPolynomial σ R) :
(rename f φ).degrees ⊆ φ.degrees.map f
|
R : Type u
σ : Type u_1
τ : Type u_2
inst✝ : CommSemiring R
f : σ → τ
φ : MvPolynomial σ R
⊢ ((rename f) φ).degrees ⊆ Multiset.map f φ.degrees
|
classical
intro i
rw [mem_degrees, Multiset.mem_map]
rintro ⟨d, hd, hi⟩
obtain ⟨x, rfl, hx⟩ := coeff_rename_ne_zero _ _ _ hd
simp only [Finsupp.mapDomain, Finsupp.mem_support_iff] at hi
rw [sum_apply, Finsupp.sum] at hi
contrapose! hi
rw [Finset.sum_eq_zero]
intro j hj
simp only [exists_prop, mem_degrees] at hi
specialize hi j ⟨x, hx, hj⟩
rw [Finsupp.single_apply, if_neg hi]
|
no goals
|
b4bc66e6c91de3f2
|
LinearMap.finrank_range_add_finrank_ker
|
Mathlib/LinearAlgebra/FiniteDimensional.lean
|
theorem finrank_range_add_finrank_ker [FiniteDimensional K V] (f : V →ₗ[K] V₂) :
finrank K (LinearMap.range f) + finrank K (LinearMap.ker f) = finrank K V
|
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V₂
⊢ finrank K (V ⧸ ker f) + finrank K ↥(ker f) = finrank K V
|
exact Submodule.finrank_quotient_add_finrank _
|
no goals
|
4e1d011075378c2d
|
CompleteOrthogonalIdempotents.iff_ortho_complete
|
Mathlib/RingTheory/Idempotents.lean
|
/-- If a family is complete orthogonal, it consists of idempotents. -/
lemma CompleteOrthogonalIdempotents.iff_ortho_complete :
CompleteOrthogonalIdempotents e ↔ Pairwise (e · * e · = 0) ∧ ∑ i, e i = 1
|
R : Type u_1
inst✝¹ : Semiring R
I : Type u_3
e : I → R
inst✝ : Fintype I
⊢ CompleteOrthogonalIdempotents e ↔ (Pairwise fun x1 x2 => e x1 * e x2 = 0) ∧ ∑ i : I, e i = 1
|
rw [completeOrthogonalIdempotents_iff, orthogonalIdempotents_iff, and_assoc, and_iff_right_of_imp]
|
R : Type u_1
inst✝¹ : Semiring R
I : Type u_3
e : I → R
inst✝ : Fintype I
⊢ (Pairwise fun x1 x2 => e x1 * e x2 = 0) ∧ ∑ i : I, e i = 1 → ∀ (i : I), IsIdempotentElem (e i)
|
5c7c10bb3cc35a64
|
AffineSubspace.wSameSide_and_wOppSide_iff
|
Mathlib/Analysis/Convex/Side.lean
|
theorem wSameSide_and_wOppSide_iff {s : AffineSubspace R P} {x y : P} :
s.WSameSide x y ∧ s.WOppSide x y ↔ x ∈ s ∨ y ∈ s
|
case mp
R : Type u_1
V : Type u_2
P : Type u_4
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
s : AffineSubspace R P
x y : P
⊢ s.WSameSide x y ∧ s.WOppSide x y → x ∈ s ∨ y ∈ s
|
rintro ⟨hs, ho⟩
|
case mp.intro
R : Type u_1
V : Type u_2
P : Type u_4
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
s : AffineSubspace R P
x y : P
hs : s.WSameSide x y
ho : s.WOppSide x y
⊢ x ∈ s ∨ y ∈ s
|
f4466fd45c8d23c6
|
MeasureTheory.MemLp.eLpNormEssSup_indicator_norm_ge_eq_zero
|
Mathlib/MeasureTheory/Function/UniformIntegrable.lean
|
theorem MemLp.eLpNormEssSup_indicator_norm_ge_eq_zero (hf : MemLp f ∞ μ)
(hmeas : StronglyMeasurable f) :
∃ M : ℝ, eLpNormEssSup ({ x | M ≤ ‖f x‖₊ }.indicator f) μ = 0
|
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f : α → β
hf : MemLp f ⊤ μ
hmeas : StronglyMeasurable f
hbdd : eLpNormEssSup f μ < ⊤
⊢ eLpNormEssSup ({x | (eLpNorm f ⊤ μ + 1).toReal ≤ ↑‖f x‖₊}.indicator f) μ = 0
|
rw [eLpNormEssSup_indicator_eq_eLpNormEssSup_restrict]
|
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f : α → β
hf : MemLp f ⊤ μ
hmeas : StronglyMeasurable f
hbdd : eLpNormEssSup f μ < ⊤
⊢ eLpNormEssSup f (μ.restrict {x | (eLpNorm f ⊤ μ + 1).toReal ≤ ↑‖f x‖₊}) = 0
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f : α → β
hf : MemLp f ⊤ μ
hmeas : StronglyMeasurable f
hbdd : eLpNormEssSup f μ < ⊤
⊢ MeasurableSet {x | (eLpNorm f ⊤ μ + 1).toReal ≤ ↑‖f x‖₊}
|
ee15b826545be751
|
Valuation.map_one_add_of_lt
|
Mathlib/RingTheory/Valuation/Basic.lean
|
theorem map_one_add_of_lt (h : v x < 1) : v (1 + x) = 1
|
R : Type u_3
Γ₀ : Type u_4
inst✝¹ : Ring R
inst✝ : LinearOrderedCommMonoidWithZero Γ₀
v : Valuation R Γ₀
x : R
h : v x < v 1
⊢ v (1 + x) = 1
|
simpa only [v.map_one] using v.map_add_eq_of_lt_left h
|
no goals
|
7e61d6fa588dc2ee
|
WellFounded.prod_lex_of_wellFoundedOn_fiber
|
Mathlib/Order/WellFoundedSet.lean
|
theorem WellFounded.prod_lex_of_wellFoundedOn_fiber (hα : WellFounded (rα on f))
(hβ : ∀ a, (f ⁻¹' {a}).WellFoundedOn (rβ on g)) :
WellFounded (Prod.Lex rα rβ on fun c => (f c, g c))
|
α : Type u_2
β : Type u_3
γ : Type u_4
rα : α → α → Prop
rβ : β → β → Prop
f : γ → α
g : γ → β
hα : WellFounded (rα on f)
hβ : ∀ (a : α), (f ⁻¹' {a}).WellFoundedOn (rβ on g)
⊢ WellFounded (Prod.Lex rα rβ on fun c => (f c, g c))
|
refine ((psigma_lex (wellFoundedOn_range.2 hα) fun a => hβ a).onFun
(f := fun c => ⟨⟨_, c, rfl⟩, c, rfl⟩)).mono fun c c' h => ?_
|
α : Type u_2
β : Type u_3
γ : Type u_4
rα : α → α → Prop
rβ : β → β → Prop
f : γ → α
g : γ → β
hα : WellFounded (rα on f)
hβ : ∀ (a : α), (f ⁻¹' {a}).WellFoundedOn (rβ on g)
c c' : γ
h : (Prod.Lex rα rβ on fun c => (f c, g c)) c c'
⊢ ((PSigma.Lex (fun a b => rα ↑a ↑b) fun a a_1 b => (rβ on g) ↑a_1 ↑b) on fun c => ⟨⟨f c, ⋯⟩, ⟨c, ⋯⟩⟩) c c'
|
56092b86f3486016
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.