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
|
|---|---|---|---|---|---|---|
ONote.split_dvd
|
Mathlib/SetTheory/Ordinal/Notation.lean
|
theorem split_dvd {o o' m} [NF o] (h : split o = (o', m)) : ω ∣ repr o'
|
case mk
o : ONote
m : ℕ
inst✝ : o.NF
a : ONote
n : ℕ
e : o.split' = (a, n)
snd_eq✝ : n = m
⊢ ω ∣ (scale 1 a).repr
|
cases nf_repr_split' e
|
case mk.intro
o : ONote
m : ℕ
inst✝ : o.NF
a : ONote
n : ℕ
e : o.split' = (a, n)
snd_eq✝ : n = m
left✝ : a.NF
right✝ : o.repr = ω * a.repr + ↑n
⊢ ω ∣ (scale 1 a).repr
|
86e9373ce6e65b94
|
borel_eq_generateFrom_of_subbasis
|
Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
|
theorem borel_eq_generateFrom_of_subbasis {s : Set (Set α)} [t : TopologicalSpace α]
[SecondCountableTopology α] (hs : t = .generateFrom s) : borel α = .generateFrom s :=
le_antisymm
(generateFrom_le fun u (hu : t.IsOpen u) => by
rw [hs] at hu
induction hu with
| basic u hu => exact GenerateMeasurable.basic u hu
| univ => exact @MeasurableSet.univ α (generateFrom s)
| inter s₁ s₂ _ _ hs₁ hs₂ => exact @MeasurableSet.inter α (generateFrom s) _ _ hs₁ hs₂
| sUnion f hf ih =>
rcases isOpen_sUnion_countable f (by rwa [hs]) with ⟨v, hv, vf, vu⟩
rw [← vu]
exact @MeasurableSet.sUnion α (generateFrom s) _ hv fun x xv => ih _ (vf xv))
(generateFrom_le fun u hu =>
GenerateMeasurable.basic _ <| show t.IsOpen u by rw [hs]; exact GenerateOpen.basic _ hu)
|
case sUnion.intro.intro.intro
α : Type u_1
s : Set (Set α)
t : TopologicalSpace α
inst✝ : SecondCountableTopology α
hs : t = TopologicalSpace.generateFrom s
u : Set α
f : Set (Set α)
hf : ∀ s_1 ∈ f, GenerateOpen s s_1
ih : ∀ s_1 ∈ f, MeasurableSet s_1
v : Set (Set α)
hv : v.Countable
vf : v ⊆ f
vu : ⋃₀ v = ⋃₀ f
⊢ MeasurableSet (⋃₀ v)
|
exact @MeasurableSet.sUnion α (generateFrom s) _ hv fun x xv => ih _ (vf xv)
|
no goals
|
95f3ad778a5ab9a8
|
Real.sinh_sub_id_strictMono
|
Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
|
theorem sinh_sub_id_strictMono : StrictMono fun x => sinh x - x
|
case refine_2
x : ℝ
hx : 0 < x
⊢ 0 < deriv (fun x => sinh x - x) x
|
rw [deriv_sub, deriv_sinh, deriv_id'', sub_pos, one_lt_cosh]
|
case refine_2
x : ℝ
hx : 0 < x
⊢ x ≠ 0
case refine_2.hf
x : ℝ
hx : 0 < x
⊢ DifferentiableAt ℝ sinh x
case refine_2.hg
x : ℝ
hx : 0 < x
⊢ DifferentiableAt ℝ (fun x => x) x
|
6a7e41008e3f2d58
|
Set.Iic.coe_iSup
|
Mathlib/Order/CompleteLatticeIntervals.lean
|
theorem coe_iSup : (↑(⨆ i, f i) : α) = ⨆ i, (f i : α)
|
case e_a.h
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
a : α
f : ι → ↑(Iic a)
x✝ : α
⊢ (x✝ ∈ Subtype.val '' range fun i => f i) ↔ x✝ ∈ range fun i => ↑(f i)
|
simp
|
no goals
|
2881ea5d6a16fbe1
|
MeasureTheory.tendsto_sum_indicator_atTop_iff
|
Mathlib/Probability/Martingale/BorelCantelli.lean
|
theorem tendsto_sum_indicator_atTop_iff [IsFiniteMeasure μ]
(hfmono : ∀ᵐ ω ∂μ, ∀ n, f n ω ≤ f (n + 1) ω) (hf : Adapted ℱ f) (hint : ∀ n, Integrable (f n) μ)
(hbdd : ∀ᵐ ω ∂μ, ∀ n, |f (n + 1) ω - f n ω| ≤ R) :
∀ᵐ ω ∂μ, Tendsto (fun n => f n ω) atTop atTop ↔
Tendsto (fun n => predictablePart f ℱ μ n ω) atTop atTop
|
case h.mp.refine_1
Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hfmono : ∀ᵐ (ω : Ω) ∂μ, ∀ (n : ℕ), f n ω ≤ f (n + 1) ω
hf : Adapted ℱ f
hint : ∀ (n : ℕ), Integrable (f n) μ
hbdd : ∀ᵐ (ω : Ω) ∂μ, ∀ (n : ℕ), |f (n + 1) ω - f n ω| ≤ ↑R
h₁ : ∀ᵐ (ω : Ω) ∂μ, ¬Tendsto (fun n => martingalePart f ℱ μ n ω) atTop atTop
h₂ : ∀ᵐ (ω : Ω) ∂μ, ¬Tendsto (fun n => martingalePart f ℱ μ n ω) atTop atBot
h₃ : ∀ᵐ (ω : Ω) ∂μ, ∀ (n : ℕ), 0 ≤ (μ[f (n + 1) - f n|↑ℱ n]) ω
ω : Ω
hω₁ : ¬Tendsto (fun n => martingalePart f ℱ μ n ω) atTop atTop
hω₂ : ¬Tendsto (fun n => martingalePart f ℱ μ n ω) atTop atBot
hω₃ : ∀ (n : ℕ), 0 ≤ (μ[f (n + 1) - f n|↑ℱ n]) ω
hω₄ : ∀ (n : ℕ), f n ω ≤ f (n + 1) ω
ht : Tendsto (fun n => f n ω) atTop atTop
n m : ℕ
hnm : n ≤ m
⊢ (fun n => predictablePart f ℱ μ n ω) n ≤ (fun n => predictablePart f ℱ μ n ω) m
|
simp only [predictablePart, Finset.sum_apply]
|
case h.mp.refine_1
Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hfmono : ∀ᵐ (ω : Ω) ∂μ, ∀ (n : ℕ), f n ω ≤ f (n + 1) ω
hf : Adapted ℱ f
hint : ∀ (n : ℕ), Integrable (f n) μ
hbdd : ∀ᵐ (ω : Ω) ∂μ, ∀ (n : ℕ), |f (n + 1) ω - f n ω| ≤ ↑R
h₁ : ∀ᵐ (ω : Ω) ∂μ, ¬Tendsto (fun n => martingalePart f ℱ μ n ω) atTop atTop
h₂ : ∀ᵐ (ω : Ω) ∂μ, ¬Tendsto (fun n => martingalePart f ℱ μ n ω) atTop atBot
h₃ : ∀ᵐ (ω : Ω) ∂μ, ∀ (n : ℕ), 0 ≤ (μ[f (n + 1) - f n|↑ℱ n]) ω
ω : Ω
hω₁ : ¬Tendsto (fun n => martingalePart f ℱ μ n ω) atTop atTop
hω₂ : ¬Tendsto (fun n => martingalePart f ℱ μ n ω) atTop atBot
hω₃ : ∀ (n : ℕ), 0 ≤ (μ[f (n + 1) - f n|↑ℱ n]) ω
hω₄ : ∀ (n : ℕ), f n ω ≤ f (n + 1) ω
ht : Tendsto (fun n => f n ω) atTop atTop
n m : ℕ
hnm : n ≤ m
⊢ ∑ c ∈ Finset.range n, (μ[f (c + 1) - f c|↑ℱ c]) ω ≤ ∑ c ∈ Finset.range m, (μ[f (c + 1) - f c|↑ℱ c]) ω
|
a9fbe9b501f842e9
|
Polynomial.coeff_ofFinsupp
|
Mathlib/Algebra/Polynomial/Basic.lean
|
theorem coeff_ofFinsupp (p) : coeff (⟨p⟩ : R[X]) = p
|
R : Type u
inst✝ : Semiring R
p : R[ℕ]
⊢ { toFinsupp := p }.coeff = ⇑p
|
rw [coeff]
|
no goals
|
ec1fe4e80b08672a
|
Array.foldlM_filter
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Monadic.lean
|
theorem foldlM_filter [Monad m] [LawfulMonad m] (p : α → Bool) (g : β → α → m β)
(l : Array α) (init : β) (w : stop = (l.filter p).size) :
(l.filter p).foldlM g init 0 stop =
l.foldlM (fun x y => if p y then g x y else pure x) init
|
m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
p : α → Bool
g : β → α → m β
l : Array α
init : β
⊢ foldlM g init (filter p l) = foldlM (fun x y => if p y = true then g x y else pure x) init l
|
cases l
|
case mk
m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
p : α → Bool
g : β → α → m β
init : β
toList✝ : List α
⊢ foldlM g init (filter p { toList := toList✝ }) =
foldlM (fun x y => if p y = true then g x y else pure x) init { toList := toList✝ }
|
54c58a709caed831
|
List.IsInfix.filterMap
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Sublist.lean
|
theorem IsInfix.filterMap {β} (f : α → Option β) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+: l₂) :
filterMap f l₁ <:+: filterMap f l₂
|
case intro.intro
α : Type u_1
β : Type u_2
f : α → Option β
l₁ xs ys : List α
⊢ List.filterMap f l₁ <:+: List.filterMap f xs ++ List.filterMap f l₁ ++ List.filterMap f ys
|
apply infix_append
|
no goals
|
124f10e693a6e10b
|
AddCircle.ergodic_zsmul_add
|
Mathlib/Dynamics/Ergodic/AddCircle.lean
|
theorem ergodic_zsmul_add (x : AddCircle T) {n : ℤ} (h : 1 < |n|) : Ergodic fun y => n • y + x
|
T : ℝ
hT : Fact (0 < T)
x : AddCircle T
n : ℤ
f : AddCircle T → AddCircle T := fun y => n • y + x
e : AddCircle T ≃ᵐ AddCircle T := MeasurableEquiv.addLeft (DivisibleBy.div x (n - 1))
he : MeasurePreserving (⇑e) volume volume
h : n - 1 ≠ 0
⊢ n • DivisibleBy.div x (n - 1) = x + DivisibleBy.div x (n - 1)
|
conv_rhs => congr; rw [← DivisibleBy.div_cancel x h]
|
T : ℝ
hT : Fact (0 < T)
x : AddCircle T
n : ℤ
f : AddCircle T → AddCircle T := fun y => n • y + x
e : AddCircle T ≃ᵐ AddCircle T := MeasurableEquiv.addLeft (DivisibleBy.div x (n - 1))
he : MeasurePreserving (⇑e) volume volume
h : n - 1 ≠ 0
⊢ n • DivisibleBy.div x (n - 1) = (n - 1) • DivisibleBy.div x (n - 1) + DivisibleBy.div x (n - 1)
|
05c20060c1761793
|
NonUnitalStarSubalgebra.iSupLift_inclusion
|
Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
|
theorem iSupLift_inclusion {i : ι} (x : K i) (h : K i ≤ T) :
iSupLift K dir f hf T hT (inclusion h x) = f i x
|
case h
R : Type u
A : Type v
B : Type w
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : NonUnitalSemiring A
inst✝⁹ : StarRing A
inst✝⁸ : Module R A
inst✝⁷ : NonUnitalSemiring B
inst✝⁶ : StarRing B
inst✝⁵ : Module R B
ι : Type u_1
inst✝⁴ : StarRing R
inst✝³ : IsScalarTower R A A
inst✝² : SMulCommClass R A A
inst✝¹ : StarModule R A
inst✝ : Nonempty ι
K : ι → NonUnitalStarSubalgebra R A
dir : Directed (fun x1 x2 => x1 ≤ x2) K
f : (i : ι) → ↥(K i) →⋆ₙₐ[R] B
hf : ∀ (i j : ι) (h : K i ≤ K j), f i = (f j).comp (inclusion h)
i : ι
x : ↥(K i)
h : K i ≤ iSup K
⊢ ↑(K i) ⊆ ↑(iSup K)
|
exact h
|
no goals
|
99a36d2072712ece
|
Array.foldlM_append'
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
|
theorem foldlM_append' [Monad m] [LawfulMonad m] (f : β → α → m β) (b) (l l' : Array α)
(w : stop = l.size + l'.size) :
(l ++ l').foldlM f b 0 stop = l.foldlM f b >>= l'.foldlM f
|
case mk.mk
m : Type u_1 → Type u_2
β : Type u_1
α : Type u_3
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : β → α → m β
b : β
l l' : List α
⊢ foldlM f b ({ toList := l } ++ { toList := l' }) 0 ({ toList := l }.size + { toList := l' }.size) = do
let init ← foldlM f b { toList := l }
foldlM f init { toList := l' }
|
simp
|
no goals
|
01331f0cf3e76f5b
|
EuclideanGeometry.dist_div_cos_angle_of_angle_eq_pi_div_two
|
Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean
|
theorem dist_div_cos_angle_of_angle_eq_pi_div_two {p₁ p₂ p₃ : P} (h : ∠ p₁ p₂ p₃ = π / 2)
(h0 : p₁ = p₂ ∨ p₃ ≠ p₂) : dist p₃ p₂ / Real.cos (∠ p₂ p₃ p₁) = dist p₁ p₃
|
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : inner (p₂ -ᵥ p₃) (p₁ -ᵥ p₂) = 0
h0 : p₂ -ᵥ p₃ ≠ 0 ∨ p₁ -ᵥ p₂ = 0
⊢ dist p₃ p₂ / Real.cos (∠ p₂ p₃ p₁) = dist p₁ p₃
|
rw [angle, dist_eq_norm_vsub' V p₃ p₂, dist_eq_norm_vsub V p₁ p₃, ← vsub_add_vsub_cancel p₁ p₂ p₃,
add_comm, norm_div_cos_angle_add_of_inner_eq_zero h h0]
|
no goals
|
1b78c9d197eba1ad
|
Matrix.Pivot.exists_list_transvec_mul_mul_list_transvec_eq_diagonal_induction
|
Mathlib/LinearAlgebra/Matrix/Transvection.lean
|
theorem exists_list_transvec_mul_mul_list_transvec_eq_diagonal_induction
(IH :
∀ M : Matrix (Fin r) (Fin r) 𝕜,
∃ (L₀ L₀' : List (TransvectionStruct (Fin r) 𝕜)) (D₀ : Fin r → 𝕜),
(L₀.map toMatrix).prod * M * (L₀'.map toMatrix).prod = diagonal D₀)
(M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜) :
∃ (L L' : List (TransvectionStruct (Fin r ⊕ Unit) 𝕜)) (D : Fin r ⊕ Unit → 𝕜),
(L.map toMatrix).prod * M * (L'.map toMatrix).prod = diagonal D
|
𝕜 : Type u_3
inst✝ : Field 𝕜
r : ℕ
IH :
∀ (M : Matrix (Fin r) (Fin r) 𝕜),
∃ L₀ L₀' D₀, (List.map toMatrix L₀).prod * M * (List.map toMatrix L₀').prod = diagonal D₀
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
L₁ L₁' : List (TransvectionStruct (Fin r ⊕ Unit) 𝕜)
hM : ((List.map toMatrix L₁).prod * M * (List.map toMatrix L₁').prod).IsTwoBlockDiagonal
M' : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜 := (List.map toMatrix L₁).prod * M * (List.map toMatrix L₁').prod
M'' : Matrix (Fin r) (Fin r) 𝕜 := M'.toBlocks₁₁
L₀ L₀' : List (TransvectionStruct (Fin r) 𝕜)
D₀ : Fin r → 𝕜
h₀ : (List.map toMatrix L₀).prod * M'' * (List.map toMatrix L₀').prod = diagonal D₀
c : 𝕜 := M' (inr ()) (inr ())
⊢ fromBlocks M'.toBlocks₁₁ 0 0 M'.toBlocks₂₂ = fromBlocks M'' 0 0 (diagonal fun x => c)
|
rfl
|
no goals
|
1db945989babbcf8
|
Affine.Triangle.scalene_iff_dist_ne_and_dist_ne_and_dist_ne
|
Mathlib/Analysis/Normed/Affine/Simplex.lean
|
lemma scalene_iff_dist_ne_and_dist_ne_and_dist_ne {t : Triangle R P} :
t.Scalene ↔ dist (t.points 0) (t.points 1) ≠ dist (t.points 0) (t.points 2) ∧
dist (t.points 0) (t.points 1) ≠ dist (t.points 1) (t.points 2) ∧
dist (t.points 0) (t.points 2) ≠ dist (t.points 1) (t.points 2)
|
R : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring R
inst✝³ : SeminormedAddCommGroup V
inst✝² : PseudoMetricSpace P
inst✝¹ : Module R V
inst✝ : NormedAddTorsor V P
t : Triangle R P
⊢ Simplex.Scalene t ↔
dist (t.points 0) (t.points 1) ≠ dist (t.points 0) (t.points 2) ∧
dist (t.points 0) (t.points 1) ≠ dist (t.points 1) (t.points 2) ∧
dist (t.points 0) (t.points 2) ≠ dist (t.points 1) (t.points 2)
|
refine ⟨fun h ↦
⟨h.dist_ne (by decide : (0 : Fin 3) ≠ 1) (by decide : (0 : Fin 3) ≠ 2) (by decide) (by decide),
h.dist_ne (by decide : (0 : Fin 3) ≠ 1) (by decide : (1 : Fin 3) ≠ 2) (by decide) (by decide),
h.dist_ne (by decide : (0 : Fin 3) ≠ 2) (by decide : (1 : Fin 3) ≠ 2) (by decide) (by decide)⟩,
fun ⟨h₁, h₂, h₃⟩ ↦ ?_⟩
|
R : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring R
inst✝³ : SeminormedAddCommGroup V
inst✝² : PseudoMetricSpace P
inst✝¹ : Module R V
inst✝ : NormedAddTorsor V P
t : Triangle R P
x✝ :
dist (t.points 0) (t.points 1) ≠ dist (t.points 0) (t.points 2) ∧
dist (t.points 0) (t.points 1) ≠ dist (t.points 1) (t.points 2) ∧
dist (t.points 0) (t.points 2) ≠ dist (t.points 1) (t.points 2)
h₁ : dist (t.points 0) (t.points 1) ≠ dist (t.points 0) (t.points 2)
h₂ : dist (t.points 0) (t.points 1) ≠ dist (t.points 1) (t.points 2)
h₃ : dist (t.points 0) (t.points 2) ≠ dist (t.points 1) (t.points 2)
⊢ Simplex.Scalene t
|
db09e2b7b29c27ae
|
CategoryTheory.IsPullback.inl_snd'
|
Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
|
theorem inl_snd' {b : BinaryBicone X Y} (h : b.IsBilimit) :
IsPullback b.inl (0 : X ⟶ 0) b.snd (0 : 0 ⟶ Y)
|
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y : C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : b.IsBilimit
⊢ IsPullback (b.inl ≫ b.fst) 0 0 (0 ≫ 0)
|
simp
|
no goals
|
c7eabf364f79dd8d
|
MeasureTheory.IsStoppingTime.measurableSet_lt_of_pred
|
Mathlib/Probability/Process/Stopping.lean
|
theorem IsStoppingTime.measurableSet_lt_of_pred [PredOrder ι] (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[f i] {ω | τ ω < i}
|
Ω : Type u_1
ι : Type u_3
m : MeasurableSpace Ω
inst✝¹ : Preorder ι
f : Filtration ι m
τ : Ω → ι
inst✝ : PredOrder ι
hτ : IsStoppingTime f τ
i : ι
hi_min : IsMin i
this : {ω | τ ω < i} = ∅
⊢ MeasurableSet {ω | τ ω < i}
|
rw [this]
|
Ω : Type u_1
ι : Type u_3
m : MeasurableSpace Ω
inst✝¹ : Preorder ι
f : Filtration ι m
τ : Ω → ι
inst✝ : PredOrder ι
hτ : IsStoppingTime f τ
i : ι
hi_min : IsMin i
this : {ω | τ ω < i} = ∅
⊢ MeasurableSet ∅
|
9a3bc634c9a3c058
|
StieltjesFunction.outer_trim
|
Mathlib/MeasureTheory/Measure/Stieltjes.lean
|
theorem outer_trim : f.outer.trim = f.outer
|
f : StieltjesFunction
s : Set ℝ
t : ℕ → Set ℝ
ht : s ⊆ ⋃ i, t i
ε : ℝ≥0
ε0 : 0 < ε
h : ∑' (i : ℕ), f.length (t i) < ⊤
ε' : ℕ → ℝ≥0
ε'0 : ∀ (i : ℕ), 0 < ε' i
hε : ∑' (i : ℕ), ↑(ε' i) < ↑ε
i : ℕ
a b : ℝ
h₁ : t i ⊆ Ioc a b
h₂ : f.outer (Ioc a b) < f.length (t i) + ↑(ε' i)
⊢ f.outer (Ioc a b) < f.length (t i) + ofReal ↑(ε' i)
|
simpa using h₂
|
no goals
|
f9dd01cdb673361c
|
OreLocalization.add''_char
|
Mathlib/RingTheory/OreLocalization/Basic.lean
|
theorem add''_char (r₁ : X) (s₁ : S) (r₂ : X) (s₂ : S) (rb : R) (sb : R)
(hb : sb * s₁ = rb * s₂) (h : sb * s₁ ∈ S) :
add'' r₁ s₁ r₂ s₂ = (sb • r₁ + rb • r₂) /ₒ ⟨sb * s₁, h⟩
|
R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddMonoid X
inst✝ : DistribMulAction R X
r₁ : X
s₁ : ↥S
r₂ : X
s₂ : ↥S
rb sb : R
hb : sb * ↑s₁ = rb * ↑s₂
h : sb * ↑s₁ ∈ S
ra : R
sa : ↥S
ha : ↑sa * ↑s₁ = ra * ↑s₂
rc : R
sc : ↥S
hc : ↑sc * sb = rc * ↑sa
⊢ ↑sc * rb * ↑s₂ = rc * ra * ↑s₂
|
rw [mul_assoc rc, ← ha, ← mul_assoc, ← hc, mul_assoc, mul_assoc, hb]
|
no goals
|
b4e8e56da73063e8
|
FirstOrder.Language.equiv_between_cg
|
Mathlib/ModelTheory/PartialEquiv.lean
|
theorem equiv_between_cg (M_cg : Structure.CG L M) (N_cg : Structure.CG L N)
(g : L.FGEquiv M N)
(ext_dom : L.IsExtensionPair M N)
(ext_cod : L.IsExtensionPair N M) :
∃ f : M ≃[L] N, g ≤ f.toEmbedding.toPartialEquiv
|
case mk.intro.intro.mk.intro.intro
L : Language
M : Type w
N : Type w'
inst✝¹ : L.Structure M
inst✝ : L.Structure N
g : L.FGEquiv M N
ext_dom : L.IsExtensionPair M N
ext_cod : L.IsExtensionPair N M
X : Set M
X_count : X.Countable
X_gen : (closure L).toFun X = ⊤
Y : Set N
Y_count : Y.Countable
Y_gen : (closure L).toFun Y = ⊤
x✝⁵ : Countable ↑X
x✝⁴ : Encodable ↑X
x✝³ : Countable ↑Y
x✝² : Encodable ↑Y
D : ↑X ⊕ ↑Y → Order.Cofinal (L.FGEquiv M N) :=
fun p => Sum.recOn p (fun x => ext_dom.definedAtLeft ↑x) fun y => ext_cod.definedAtRight ↑y
S : ℕ →o M ≃ₚ[L] N := { toFun := Subtype.val ∘ Order.sequenceOfCofinals g D, monotone' := ⋯ }
F : M ≃ₚ[L] N := partialEquivLimit S
x✝¹ : X ⊆ ↑F.dom
x✝ : Y ⊆ ↑F.cod
dom_top : F.dom = ⊤
cod_top : F.cod = ⊤
⊢ ∃ f, ↑g ≤ f.toEmbedding.toPartialEquiv
|
refine ⟨toEquivOfEqTop dom_top cod_top, ?_⟩
|
case mk.intro.intro.mk.intro.intro
L : Language
M : Type w
N : Type w'
inst✝¹ : L.Structure M
inst✝ : L.Structure N
g : L.FGEquiv M N
ext_dom : L.IsExtensionPair M N
ext_cod : L.IsExtensionPair N M
X : Set M
X_count : X.Countable
X_gen : (closure L).toFun X = ⊤
Y : Set N
Y_count : Y.Countable
Y_gen : (closure L).toFun Y = ⊤
x✝⁵ : Countable ↑X
x✝⁴ : Encodable ↑X
x✝³ : Countable ↑Y
x✝² : Encodable ↑Y
D : ↑X ⊕ ↑Y → Order.Cofinal (L.FGEquiv M N) :=
fun p => Sum.recOn p (fun x => ext_dom.definedAtLeft ↑x) fun y => ext_cod.definedAtRight ↑y
S : ℕ →o M ≃ₚ[L] N := { toFun := Subtype.val ∘ Order.sequenceOfCofinals g D, monotone' := ⋯ }
F : M ≃ₚ[L] N := partialEquivLimit S
x✝¹ : X ⊆ ↑F.dom
x✝ : Y ⊆ ↑F.cod
dom_top : F.dom = ⊤
cod_top : F.cod = ⊤
⊢ ↑g ≤ (toEquivOfEqTop dom_top cod_top).toEmbedding.toPartialEquiv
|
d1b972cd720b6e06
|
Array.lt_iff_exists
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Lex/Lemmas.lean
|
theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁ l₂ : Array α} :
l₁ < l₂ ↔
(l₁ = l₂.take l₁.size ∧ l₁.size < l₂.size) ∨
(∃ (i : Nat) (h₁ : i < l₁.size) (h₂ : i < l₂.size),
(∀ j, (hj : j < i) →
l₁[j]'(Nat.lt_trans hj h₁) = l₂[j]'(Nat.lt_trans hj h₂)) ∧ l₁[i] < l₂[i])
|
case mk
α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : LT α
inst✝ : DecidableLT α
l₂ : Array α
toList✝ : List α
⊢ { toList := toList✝ } < l₂ ↔
{ toList := toList✝ } = l₂.take { toList := toList✝ }.size ∧ { toList := toList✝ }.size < l₂.size ∨
∃ i h₁ h₂, (∀ (j : Nat) (hj : j < i), { toList := toList✝ }[j] = l₂[j]) ∧ { toList := toList✝ }[i] < l₂[i]
|
cases l₂
|
case mk.mk
α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : LT α
inst✝ : DecidableLT α
toList✝¹ toList✝ : List α
⊢ { toList := toList✝¹ } < { toList := toList✝ } ↔
{ toList := toList✝¹ } = { toList := toList✝ }.take { toList := toList✝¹ }.size ∧
{ toList := toList✝¹ }.size < { toList := toList✝ }.size ∨
∃ i h₁ h₂,
(∀ (j : Nat) (hj : j < i), { toList := toList✝¹ }[j] = { toList := toList✝ }[j]) ∧
{ toList := toList✝¹ }[i] < { toList := toList✝ }[i]
|
ae7954081a1c04fb
|
Finset.prod_dite
|
Mathlib/Algebra/BigOperators/Group/Finset/Basic.lean
|
theorem prod_dite {s : Finset α} {p : α → Prop} {hp : DecidablePred p} (f : ∀ x : α, p x → β)
(g : ∀ x : α, ¬p x → β) :
∏ x ∈ s, (if hx : p x then f x hx else g x hx) =
(∏ x : {x ∈ s | p x}, f x.1 (by simpa using (mem_filter.mp x.2).2)) *
∏ x : {x ∈ s | ¬p x}, g x.1 (by simpa using (mem_filter.mp x.2).2)
|
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
s : Finset α
p : α → Prop
hp : DecidablePred p
f : (x : α) → p x → β
g : (x : α) → ¬p x → β
x : { x // x ∈ filter (fun x => ¬p x) s }
⊢ ¬p ↑x
|
simpa using (mem_filter.mp x.2).2
|
no goals
|
dc94d4cafa1d0c81
|
Finsupp.embDomain_apply
|
Mathlib/Data/Finsupp/Defs.lean
|
theorem embDomain_apply (f : α ↪ β) (v : α →₀ M) (a : α) : embDomain f v (f a) = v a
|
case pos
α : Type u_1
β : Type u_2
M : Type u_5
inst✝ : Zero M
f : α ↪ β
v : α →₀ M
a : α
h✝ : f a ∈ map f v.support
h : a ∈ v.support
⊢ v (choose (fun a₁ => f a₁ = f a) v.support ⋯) = v a
|
refine congr_arg (v : α → M) (f.inj' ?_)
|
case pos
α : Type u_1
β : Type u_2
M : Type u_5
inst✝ : Zero M
f : α ↪ β
v : α →₀ M
a : α
h✝ : f a ∈ map f v.support
h : a ∈ v.support
⊢ f.toFun (choose (fun a₁ => f a₁ = f a) v.support ⋯) = f.toFun a
|
f564562eef1563c7
|
mellin_hasDerivAt_of_isBigO_rpow
|
Mathlib/Analysis/MellinTransform.lean
|
theorem mellin_hasDerivAt_of_isBigO_rpow [NormedSpace ℂ E] {a b : ℝ}
{f : ℝ → E} {s : ℂ} (hfc : LocallyIntegrableOn f (Ioi 0)) (hf_top : f =O[atTop] (· ^ (-a)))
(hs_top : s.re < a) (hf_bot : f =O[𝓝[>] 0] (· ^ (-b))) (hs_bot : b < s.re) :
MellinConvergent (fun t => log t • f t) s ∧
HasDerivAt (mellin f) (mellin (fun t => log t • f t) s) s
|
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b : ℝ
f : ℝ → E
s : ℂ
hfc : LocallyIntegrableOn f (Ioi 0) volume
hf_top : f =O[atTop] fun x => x ^ (-a)
hs_top : s.re < a
hf_bot : f =O[𝓝[>] 0] fun x => x ^ (-b)
hs_bot : b < s.re
F : ℂ → ℝ → E := fun z t => ↑t ^ (z - 1) • f t
F' : ℂ → ℝ → E := fun z t => (↑t ^ (z - 1) * ↑(log t)) • f t
v : ℝ
hv0 : 0 < v
hv1 : v < s.re - b
hv2 : v < a - s.re
bound : ℝ → ℝ := fun t => (t ^ (s.re + v - 1) + t ^ (s.re - v - 1)) * |log t| * ‖f t‖
h1 : ∀ᶠ (z : ℂ) in 𝓝 s, AEStronglyMeasurable (F z) (volume.restrict (Ioi 0))
h2 : IntegrableOn (F s) (Ioi 0) volume
h3 : AEStronglyMeasurable (F' s) (volume.restrict (Ioi 0))
t : ℝ
ht : t ∈ Ioi 0
z : ℂ
hz : z ∈ Metric.ball s v
⊢ ‖F' z t‖ ≤ bound t
|
simp_rw [F', bound, norm_smul, norm_mul, norm_real, mul_assoc]
|
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b : ℝ
f : ℝ → E
s : ℂ
hfc : LocallyIntegrableOn f (Ioi 0) volume
hf_top : f =O[atTop] fun x => x ^ (-a)
hs_top : s.re < a
hf_bot : f =O[𝓝[>] 0] fun x => x ^ (-b)
hs_bot : b < s.re
F : ℂ → ℝ → E := fun z t => ↑t ^ (z - 1) • f t
F' : ℂ → ℝ → E := fun z t => (↑t ^ (z - 1) * ↑(log t)) • f t
v : ℝ
hv0 : 0 < v
hv1 : v < s.re - b
hv2 : v < a - s.re
bound : ℝ → ℝ := fun t => (t ^ (s.re + v - 1) + t ^ (s.re - v - 1)) * |log t| * ‖f t‖
h1 : ∀ᶠ (z : ℂ) in 𝓝 s, AEStronglyMeasurable (F z) (volume.restrict (Ioi 0))
h2 : IntegrableOn (F s) (Ioi 0) volume
h3 : AEStronglyMeasurable (F' s) (volume.restrict (Ioi 0))
t : ℝ
ht : t ∈ Ioi 0
z : ℂ
hz : z ∈ Metric.ball s v
⊢ ‖↑t ^ (z - 1)‖ * (‖log t‖ * ‖f t‖) ≤ (t ^ (s.re + v - 1) + t ^ (s.re - v - 1)) * (|log t| * ‖f t‖)
|
3ad5d9a87042b6f9
|
BoxIntegral.Integrable.dist_integralSum_integral_le_of_memBaseSet
|
Mathlib/Analysis/BoxIntegral/Basic.lean
|
theorem dist_integralSum_integral_le_of_memBaseSet (h : Integrable I l f vol) (h₀ : 0 < ε)
(hπ : l.MemBaseSet I c (h.convergenceR ε c) π) (hπp : π.IsPartition) :
dist (integralSum f vol π) (integral I l f vol) ≤ ε
|
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
c : ℝ≥0
ε : ℝ
h : Integrable I l f vol
h₀ : 0 < ε
hπ : l.MemBaseSet I c (h.convergenceR ε c) π
hπp : π.IsPartition
⊢ dist (integralSum f vol π) (integral I l f vol) ≤ ε
|
rw [convergenceR, dif_pos h₀] at hπ
|
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
c : ℝ≥0
ε : ℝ
h : Integrable I l f vol
h₀ : 0 < ε
hπ : l.MemBaseSet I c (⋯.choose c) π
hπp : π.IsPartition
⊢ dist (integralSum f vol π) (integral I l f vol) ≤ ε
|
a9d29982a078a587
|
LinearMap.minpoly_coeff_zero_of_injective
|
Mathlib/LinearAlgebra/Charpoly/Basic.lean
|
theorem minpoly_coeff_zero_of_injective [Nontrivial R] (hf : Function.Injective f) :
(minpoly R f).coeff 0 ≠ 0
|
case intro
R : Type u
M : Type v
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Module.Free R M
inst✝¹ : Module.Finite R M
f : M →ₗ[R] M
inst✝ : Nontrivial R
hf : Function.Injective ⇑f
h : (minpoly R f).coeff 0 = 0
P : R[X]
hP : minpoly R f = X * P
hdegP : P.degree < (minpoly R f).degree
hPmonic : P.Monic
hzero : (aeval f) (minpoly R f) = 0
⊢ False
|
simp only [hP, mul_eq_comp, LinearMap.ext_iff, hf, aeval_X, map_eq_zero_iff, coe_comp,
_root_.map_mul, zero_apply, Function.comp_apply] at hzero
|
case intro
R : Type u
M : Type v
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Module.Free R M
inst✝¹ : Module.Finite R M
f : M →ₗ[R] M
inst✝ : Nontrivial R
hf : Function.Injective ⇑f
h : (minpoly R f).coeff 0 = 0
P : R[X]
hP : minpoly R f = X * P
hdegP : P.degree < (minpoly R f).degree
hPmonic : P.Monic
hzero : ∀ (x : M), ((aeval f) P) x = 0
⊢ False
|
5bd9e33feec06141
|
Std.DHashMap.Internal.Raw.foldRev_cons
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/WF.lean
|
theorem foldRev_cons {l : Raw α β} {acc : List ((a : α) × β a)} :
l.foldRev (fun acc k v => ⟨k, v⟩ :: acc) acc = toListModel l.buckets ++ acc
|
α : Type u
β : α → Type v
l : Raw α β
acc : List ((a : α) × β a)
⊢ Raw.foldRev (fun acc k v => ⟨k, v⟩ :: acc) acc l = toListModel l.buckets ++ acc
|
simp [foldRev_cons_apply]
|
no goals
|
d17e4c0f17165021
|
ZFSet.toSet_equiv_aux
|
Mathlib/SetTheory/ZFC/Basic.lean
|
private lemma toSet_equiv_aux {s : Set ZFSet.{u}} (hs : Small.{u} s) :
(mk <| PSet.mk (Shrink s) fun x ↦ ((equivShrink s).symm x).1.out).toSet = s
|
case h.refine_1.intro
s : Set ZFSet.{u}
hs : Small.{u, u + 1} ↑s
x : ZFSet.{u}
b : (PSet.mk (Shrink.{u, u + 1} ↑s) fun x => Quotient.out ↑((equivShrink ↑s).symm x)).Type
h2 : (Quotient.out x).Equiv ((PSet.mk (Shrink.{u, u + 1} ↑s) fun x => Quotient.out ↑((equivShrink ↑s).symm x)).Func b)
⊢ x ∈ s
|
rw [← ZFSet.eq, ZFSet.mk_out] at h2
|
case h.refine_1.intro
s : Set ZFSet.{u}
hs : Small.{u, u + 1} ↑s
x : ZFSet.{u}
b : (PSet.mk (Shrink.{u, u + 1} ↑s) fun x => Quotient.out ↑((equivShrink ↑s).symm x)).Type
h2 : x = mk ((PSet.mk (Shrink.{u, u + 1} ↑s) fun x => Quotient.out ↑((equivShrink ↑s).symm x)).Func b)
⊢ x ∈ s
|
d1b549e8dc7b2bb2
|
Equidecomp.toPartialEquiv_injective
|
Mathlib/Algebra/Group/Action/Equidecomp.lean
|
theorem toPartialEquiv_injective : Injective <| toPartialEquiv (X := X) (G := G)
|
X : Type u_1
G : Type u_2
inst✝ : SMul G X
toPartialEquiv✝ : PartialEquiv X X
w✝ : Finset G
h✝ : IsDecompOn (↑toPartialEquiv✝) toPartialEquiv✝.source w✝
a₂✝ : Equidecomp X G
a✝ : { toPartialEquiv := toPartialEquiv✝, isDecompOn' := ⋯ }.toPartialEquiv = a₂✝.toPartialEquiv
⊢ { toPartialEquiv := toPartialEquiv✝, isDecompOn' := ⋯ } = a₂✝
|
congr
|
no goals
|
7b9bab81ff2aaf5e
|
List.exists_chain_of_relationReflTransGen
|
Mathlib/Data/List/Chain.lean
|
theorem exists_chain_of_relationReflTransGen (h : Relation.ReflTransGen r a b) :
∃ l, Chain r a l ∧ getLast (a :: l) (cons_ne_nil _ _) = b
|
case refine_2
α : Type u
r : α → α → Prop
a b : α
h : Relation.ReflTransGen r a b
⊢ ∀ {a c : α},
r a c →
Relation.ReflTransGen r c b →
(∃ l, Chain r c l ∧ (c :: l).getLast ⋯ = b) → ∃ l, Chain r a l ∧ (a :: l).getLast ⋯ = b
|
intro c d e _ ih
|
case refine_2
α : Type u
r : α → α → Prop
a b : α
h : Relation.ReflTransGen r a b
c d : α
e : r c d
h✝ : Relation.ReflTransGen r d b
ih : ∃ l, Chain r d l ∧ (d :: l).getLast ⋯ = b
⊢ ∃ l, Chain r c l ∧ (c :: l).getLast ⋯ = b
|
78f3a017142a6566
|
CategoryTheory.Sieve.forallYonedaIsSheaf_iff_colimit
|
Mathlib/CategoryTheory/Sites/SheafOfTypes.lean
|
theorem forallYonedaIsSheaf_iff_colimit (S : Sieve X) :
(∀ W : C, Presieve.IsSheafFor (yoneda.obj W) (S : Presieve X)) ↔
Nonempty (IsColimit S.arrows.cocone)
|
C : Type u
inst✝ : Category.{v, u} C
X : C
S : Sieve X
H : ∀ (W : C), IsSheafFor (yoneda.obj W) S.arrows
⊢ ∀ (s : Cocone S.arrows.diagram) (m : S.arrows.cocone.pt ⟶ s.pt),
(∀ (j : S.arrows.category), S.arrows.cocone.ι.app j ≫ m = s.ι.app j) → m = (fun s => Exists.choose ⋯) s
|
intro s Fs HFs
|
C : Type u
inst✝ : Category.{v, u} C
X : C
S : Sieve X
H : ∀ (W : C), IsSheafFor (yoneda.obj W) S.arrows
s : Cocone S.arrows.diagram
Fs : S.arrows.cocone.pt ⟶ s.pt
HFs : ∀ (j : S.arrows.category), S.arrows.cocone.ι.app j ≫ Fs = s.ι.app j
⊢ Fs = (fun s => Exists.choose ⋯) s
|
0cc74e895fe44091
|
Std.DHashMap.Internal.Raw₀.toListModel_mapₘ
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/WF.lean
|
theorem toListModel_mapₘ {m : Raw₀ α β} {f : (a : α) → β a → δ a} :
Perm (toListModel (m.mapₘ f).1.buckets)
((toListModel m.1.buckets).map fun p => ⟨p.1, f p.1 p.2⟩) :=
toListModel_updateAllBuckets AssocList.toList_map (by simp)
|
α : Type u
β : α → Type v
δ : α → Type w
m : Raw₀ α β
f : (a : α) → β a → δ a
⊢ ∀ {l l' : List ((a : α) × β a)},
List.map (fun p => ⟨p.fst, f p.fst p.snd⟩) (l ++ l') ~
List.map (fun p => ⟨p.fst, f p.fst p.snd⟩) l ++ List.map (fun p => ⟨p.fst, f p.fst p.snd⟩) l'
|
simp
|
no goals
|
6068394d90bb11fd
|
Ideal.homogeneousCore'_eq_sSup
|
Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean
|
theorem Ideal.homogeneousCore'_eq_sSup :
I.homogeneousCore' 𝒜 = sSup { J : Ideal A | J.IsHomogeneous 𝒜 ∧ J ≤ I }
|
case h
ι : Type u_1
σ : Type u_2
A : Type u_3
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
⊢ IsGreatest {J | IsHomogeneous 𝒜 J ∧ J ≤ I} (homogeneousCore' 𝒜 I)
|
have coe_mono : Monotone (toIdeal : HomogeneousIdeal 𝒜 → Ideal A) := fun x y => id
|
case h
ι : Type u_1
σ : Type u_2
A : Type u_3
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
coe_mono : Monotone toIdeal
⊢ IsGreatest {J | IsHomogeneous 𝒜 J ∧ J ≤ I} (homogeneousCore' 𝒜 I)
|
9432fbd8401d3b7e
|
PerfectClosure.natCast_eq_iff
|
Mathlib/FieldTheory/PerfectClosure.lean
|
theorem natCast_eq_iff (x y : ℕ) : (x : PerfectClosure K p) = y ↔ (x : K) = y
|
case mp
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y : ℕ
H : ↑x = ↑y
⊢ ↑x = ↑y
|
rw [natCast K p 0, natCast K p 0, mk_eq_iff] at H
|
case mp
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y : ℕ
H : ∃ z, (⇑(frobenius K p))^[(0, ↑y).1 + z] (0, ↑x).2 = (⇑(frobenius K p))^[(0, ↑x).1 + z] (0, ↑y).2
⊢ ↑x = ↑y
|
f69df36b38bd9cb7
|
IsLocalization.isLocalization_of_submonoid_le
|
Mathlib/RingTheory/Localization/LocalizationLocalization.lean
|
theorem isLocalization_of_submonoid_le (M N : Submonoid R) (h : M ≤ N) [IsLocalization M S]
[IsLocalization N T] [Algebra S T] [IsScalarTower R S T] :
IsLocalization (N.map (algebraMap R S)) T :=
{ map_units'
|
R : Type u_1
inst✝⁸ : CommSemiring R
S : Type u_2
inst✝⁷ : CommSemiring S
inst✝⁶ : Algebra R S
T : Type u_3
inst✝⁵ : CommSemiring T
inst✝⁴ : Algebra R T
M N : Submonoid R
h : M ≤ N
inst✝³ : IsLocalization M S
inst✝² : IsLocalization N T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
x₁ x₂ : S
y₁ : R
s₁ : ↥M
e₁ : x₁ * (algebraMap R S) ↑s₁ = (algebraMap R S) y₁
y₂ : R
s₂ : ↥M
e₂ : x₂ * (algebraMap R S) ↑s₂ = (algebraMap R S) y₂
this :
(algebraMap R T) (y₁ * ↑s₂) = (algebraMap R T) (y₂ * ↑s₁) →
∃ a, (algebraMap R S) (↑a * (y₁ * ↑s₂)) = (algebraMap R S) (↑a * (y₂ * ↑s₁))
⊢ (algebraMap S T) x₁ = (algebraMap S T) x₂ → ∃ a, (algebraMap R S) ↑a * x₁ = (algebraMap R S) ↑a * x₂
|
have h₁ := @IsUnit.mul_left_inj T _ _ (algebraMap S T x₁) (algebraMap S T x₂)
(IsLocalization.map_units T ⟨(s₁ : R), h s₁.prop⟩)
|
R : Type u_1
inst✝⁸ : CommSemiring R
S : Type u_2
inst✝⁷ : CommSemiring S
inst✝⁶ : Algebra R S
T : Type u_3
inst✝⁵ : CommSemiring T
inst✝⁴ : Algebra R T
M N : Submonoid R
h : M ≤ N
inst✝³ : IsLocalization M S
inst✝² : IsLocalization N T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
x₁ x₂ : S
y₁ : R
s₁ : ↥M
e₁ : x₁ * (algebraMap R S) ↑s₁ = (algebraMap R S) y₁
y₂ : R
s₂ : ↥M
e₂ : x₂ * (algebraMap R S) ↑s₂ = (algebraMap R S) y₂
this :
(algebraMap R T) (y₁ * ↑s₂) = (algebraMap R T) (y₂ * ↑s₁) →
∃ a, (algebraMap R S) (↑a * (y₁ * ↑s₂)) = (algebraMap R S) (↑a * (y₂ * ↑s₁))
h₁ :
(algebraMap S T) x₁ * (algebraMap R T) ↑⟨↑s₁, ⋯⟩ = (algebraMap S T) x₂ * (algebraMap R T) ↑⟨↑s₁, ⋯⟩ ↔
(algebraMap S T) x₁ = (algebraMap S T) x₂
⊢ (algebraMap S T) x₁ = (algebraMap S T) x₂ → ∃ a, (algebraMap R S) ↑a * x₁ = (algebraMap R S) ↑a * x₂
|
af3dd23a92652c9e
|
derivWithin.star
|
Mathlib/Analysis/Calculus/Deriv/Star.lean
|
theorem derivWithin.star :
derivWithin (fun y => star (f y)) s x = star (derivWithin f s x)
|
case inl
𝕜 : Type u
inst✝⁷ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
f : 𝕜 → F
inst✝⁴ : StarRing 𝕜
inst✝³ : TrivialStar 𝕜
inst✝² : StarAddMonoid F
inst✝¹ : ContinuousStar F
inst✝ : StarModule 𝕜 F
s : Set 𝕜
x : 𝕜
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ derivWithin (fun y => star (f y)) s x = star (derivWithin f s x)
|
exact DFunLike.congr_fun (fderivWithin_star hxs) _
|
no goals
|
e9c7dc1260002160
|
starConvex_iff_div
|
Mathlib/Analysis/Convex/Star.lean
|
theorem starConvex_iff_div : StarConvex 𝕜 x s ↔ ∀ ⦃y⦄, y ∈ s →
∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → 0 < a + b → (a / (a + b)) • x + (b / (a + b)) • y ∈ s :=
⟨fun h y hy a b ha hb hab => by
apply h hy
· positivity
· positivity
· rw [← add_div]
exact div_self hab.ne',
fun h y hy a b ha hb hab => by
have h' := h hy ha hb
rw [hab, div_one, div_one] at h'
exact h' zero_lt_one⟩
|
case a
𝕜 : Type u_1
E : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x : E
s : Set E
h : StarConvex 𝕜 x s
y : E
hy : y ∈ s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : 0 < a + b
⊢ 0 ≤ a / (a + b)
|
positivity
|
no goals
|
cfbb609cf4b8dfa0
|
Stream.fst_takeTR_loop
|
Mathlib/.lake/packages/batteries/Batteries/Data/Stream.lean
|
theorem fst_takeTR_loop [Stream σ α] (s : σ) (acc : List α) (n : Nat) :
(takeTR.loop s acc n).fst = acc.reverseAux (take s n).fst
|
case succ
σ : Type u_1
α : Type u_2
inst✝ : Stream σ α
n : Nat
ih : ∀ (s : σ) (acc : List α), (takeTR.loop s acc n).fst = acc.reverseAux (take s n).fst
s : σ
acc : List α
⊢ (match next? s with
| none => (acc.reverse, s)
| some (a, s) => takeTR.loop s (a :: acc) n).fst =
acc.reverseAux
(match next? s with
| none => ([], s)
| some (a, s) => (a :: (take s n).fst, (take s n).snd)).fst
|
split
|
case succ.h_1
σ : Type u_1
α : Type u_2
inst✝ : Stream σ α
n : Nat
ih : ∀ (s : σ) (acc : List α), (takeTR.loop s acc n).fst = acc.reverseAux (take s n).fst
s : σ
acc : List α
x✝ : Option (α × σ)
heq✝ : next? s = none
⊢ (acc.reverse, s).fst = acc.reverseAux ([], s).fst
case succ.h_2
σ : Type u_1
α : Type u_2
inst✝ : Stream σ α
n : Nat
ih : ∀ (s : σ) (acc : List α), (takeTR.loop s acc n).fst = acc.reverseAux (take s n).fst
s : σ
acc : List α
x✝ : Option (α × σ)
fst✝ : α
s✝ : σ
heq✝ : next? s = some (fst✝, s✝)
⊢ (takeTR.loop s✝ (fst✝ :: acc) n).fst = acc.reverseAux (fst✝ :: (take s✝ n).fst, (take s✝ n).snd).fst
|
2bffc6cbe2fbb7d5
|
FractionalIdeal.dual_eq_mul_inv
|
Mathlib/RingTheory/DedekindDomain/Different.lean
|
lemma dual_eq_mul_inv :
dual A K I = dual A K 1 * I⁻¹
|
case h.e'_3
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝¹⁸ : CommRing A
inst✝¹⁷ : Field K
inst✝¹⁶ : CommRing B
inst✝¹⁵ : Field L
inst✝¹⁴ : Algebra A K
inst✝¹³ : Algebra B L
inst✝¹² : Algebra A B
inst✝¹¹ : Algebra K L
inst✝¹⁰ : Algebra A L
inst✝⁹ : IsScalarTower A K L
inst✝⁸ : IsScalarTower A B L
inst✝⁷ : IsDomain A
inst✝⁶ : IsFractionRing A K
inst✝⁵ : FiniteDimensional K L
inst✝⁴ : Algebra.IsSeparable K L
inst✝³ : IsIntegralClosure B A L
inst✝² : IsFractionRing B L
inst✝¹ : IsIntegrallyClosed A
inst✝ : IsDedekindDomain B
I : FractionalIdeal B⁰ L
hI : ¬I = 0
this : dual A K I * I ≤ dual A K 1
⊢ dual A K I = (fun J => J * I⁻¹) (dual A K I * I)
|
simp only [mul_inv_cancel₀ hI, mul_one, mul_assoc]
|
no goals
|
ed98528f286a47a6
|
Vector.exists_mem_push
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Vector/Lemmas.lean
|
theorem exists_mem_push {p : α → Prop} {a : α} {xs : Vector α n} :
(∃ x, ∃ _ : x ∈ xs.push a, p x) ↔ p a ∨ ∃ x, ∃ _ : x ∈ xs, p x
|
case mpr.inr.intro.intro
α : Type u_1
n : Nat
p : α → Prop
a : α
xs : Vector α n
x : α
h : x ∈ xs
h' : p x
⊢ ∃ x, (x ∈ xs ∨ x = a) ∧ p x
|
exact ⟨x, .inl h, h'⟩
|
no goals
|
110c8ee2b5790ab6
|
ContinuousMap.secondCountableTopology
|
Mathlib/Topology/ContinuousMap/SecondCountableSpace.lean
|
theorem secondCountableTopology [SecondCountableTopology Y]
(hX : ∃ S : Set (Set X), S.Countable ∧ (∀ K ∈ S, IsCompact K) ∧
∀ f : C(X, Y), ∀ V, IsOpen V → ∀ x ∈ f ⁻¹' V, ∃ K ∈ S, K ∈ 𝓝 x ∧ MapsTo f K V) :
SecondCountableTopology C(X, Y) where
is_open_generated_countable
|
case intro.intro.intro.refine_2.a
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : SecondCountableTopology Y
S : Set (Set X)
hScount : S.Countable
hScomp : ∀ K ∈ S, IsCompact K
hS : ∀ (f : C(X, Y)) (V : Set Y), IsOpen V → ∀ x ∈ ⇑f ⁻¹' V, ∃ K ∈ S, K ∈ 𝓝 x ∧ MapsTo (⇑f) K V
f : C(X, Y)
x : X
V : Set Y
hV : V ∈ countableBasis Y
hx : f x ∈ V
⊢ IsOpen V
case intro.intro.intro.refine_2.a
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : SecondCountableTopology Y
S : Set (Set X)
hScount : S.Countable
hScomp : ∀ K ∈ S, IsCompact K
hS : ∀ (f : C(X, Y)) (V : Set Y), IsOpen V → ∀ x ∈ ⇑f ⁻¹' V, ∃ K ∈ S, K ∈ 𝓝 x ∧ MapsTo (⇑f) K V
f : C(X, Y)
x : X
V : Set Y
hV : V ∈ countableBasis Y
hx : f x ∈ V
⊢ x ∈ ⇑f ⁻¹' V
|
exacts [isOpen_of_mem_countableBasis hV, hx]
|
no goals
|
0dafc646dd2a456c
|
MeasureTheory.compl_cylinder
|
Mathlib/MeasureTheory/Constructions/Cylinders.lean
|
theorem compl_cylinder (s : Finset ι) (S : Set (∀ i : s, α i)) :
(cylinder s S)ᶜ = cylinder s (Sᶜ)
|
case h
ι : Type u_1
α : ι → Type u_2
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
f : (i : ι) → α i
⊢ f ∈ (cylinder s S)ᶜ ↔ f ∈ cylinder s Sᶜ
|
simp only [mem_compl_iff, mem_cylinder]
|
no goals
|
0a9d73df55e687df
|
RelSeries.smash_succ_natAdd
|
Mathlib/Order/RelSeries.lean
|
lemma smash_succ_natAdd {p q : RelSeries r} (h : p.last = q.head) (i : Fin q.length) :
smash p q h (i.natAdd p.length).succ = q i.succ
|
case neg
α : Type u_1
r : Rel α α
p q : RelSeries r
h : p.last = q.head
i : Fin q.length
H : ¬↑(Fin.natAdd p.length i).succ < p.length
⊢ q.toFun ⟨↑(Fin.natAdd p.length i).succ - p.length, ⋯⟩ = q.toFun i.succ
|
congr
|
case neg.e_a.e_val
α : Type u_1
r : Rel α α
p q : RelSeries r
h : p.last = q.head
i : Fin q.length
H : ¬↑(Fin.natAdd p.length i).succ < p.length
⊢ ↑(Fin.natAdd p.length i).succ - p.length = ↑i + 1
|
fa10ba653f3f8a7f
|
Cardinal.isPrimePow_iff
|
Mathlib/SetTheory/Cardinal/Divisibility.lean
|
theorem isPrimePow_iff {a : Cardinal} : IsPrimePow a ↔ ℵ₀ ≤ a ∨ ∃ n : ℕ, a = n ∧ IsPrimePow n
|
case neg.intro
a : ℕ
h : ¬ℵ₀ ≤ ↑a
⊢ IsPrimePow ↑a ↔ ∃ n, ↑a = ↑n ∧ ∃ p k, Nat.Prime p ∧ 0 < k ∧ p ^ k = n
|
rw [isPrimePow_def]
|
case neg.intro
a : ℕ
h : ¬ℵ₀ ≤ ↑a
⊢ (∃ p k, Prime p ∧ 0 < k ∧ p ^ k = ↑a) ↔ ∃ n, ↑a = ↑n ∧ ∃ p k, Nat.Prime p ∧ 0 < k ∧ p ^ k = n
|
a84b61c12666a126
|
RegularExpression.star_rmatch_iff
|
Mathlib/Computability/RegularExpressions.lean
|
theorem star_rmatch_iff (P : RegularExpression α) :
∀ x : List α, (star P).rmatch x ↔ ∃ S : List (List α), x
= S.flatten ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t :=
fun x => by
have IH := fun t (_h : List.length t < List.length x) => star_rmatch_iff P t
clear star_rmatch_iff
constructor
· rcases x with - | ⟨a, x⟩
· intro _h
use []; dsimp; tauto
· rw [rmatch, deriv, mul_rmatch_iff]
rintro ⟨t, u, hs, ht, hu⟩
have hwf : u.length < (List.cons a x).length
|
case mpr.intro.intro.cons.cons.cons.refine_2
α : Type u_1
inst✝ : DecidableEq α
P : RegularExpression α
a : α
x : List α
IH :
∀ (t : List α),
t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.flatten ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t✝ : List α
helem : ∀ t ∈ (b :: t✝) :: U, t ≠ [] ∧ P.rmatch t = true
hsum : a = b ∧ x = t✝ ++ U.flatten
hwf : U.flatten.length < (a :: x).length
t : List α
h : t ∈ U
⊢ t ∈ (b :: t✝) :: U
|
right
|
case mpr.intro.intro.cons.cons.cons.refine_2.a
α : Type u_1
inst✝ : DecidableEq α
P : RegularExpression α
a : α
x : List α
IH :
∀ (t : List α),
t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.flatten ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t✝ : List α
helem : ∀ t ∈ (b :: t✝) :: U, t ≠ [] ∧ P.rmatch t = true
hsum : a = b ∧ x = t✝ ++ U.flatten
hwf : U.flatten.length < (a :: x).length
t : List α
h : t ∈ U
⊢ Mem t U
|
8215ce2ddbd6bd2a
|
LocalizedModule.algebraMap_mk
|
Mathlib/Algebra/Module/LocalizedModule/Basic.lean
|
theorem algebraMap_mk {A : Type*} [Semiring A] [Algebra R A] (a : R) (s : S) :
algebraMap _ _ (Localization.mk a s) = mk (algebraMap R A a) s
|
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
A : Type u_2
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : R
s : ↥S
⊢ (algebraMap (Localization S) (LocalizedModule S A)) (Localization.mk a s) = mk ((algebraMap R A) a) s
|
rw [Localization.mk_eq_mk']
|
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
A : Type u_2
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : R
s : ↥S
⊢ (algebraMap (Localization S) (LocalizedModule S A)) (IsLocalization.mk' (Localization S) a s) =
mk ((algebraMap R A) a) s
|
5d3f59e00a22b9fa
|
MeasureTheory.eLpNorm_indicator_eq_eLpNorm_restrict
|
Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
|
lemma eLpNorm_indicator_eq_eLpNorm_restrict (hs : MeasurableSet s) :
eLpNorm (s.indicator f) p μ = eLpNorm f p (μ.restrict s)
|
case pos
α : Type u_1
F : Type u_4
m0 : MeasurableSpace α
p : ℝ≥0∞
μ : Measure α
inst✝ : NormedAddCommGroup F
f : α → F
s : Set α
hs : MeasurableSet s
hp_zero : ¬p = 0
hp_top : p = ⊤
⊢ eLpNorm (s.indicator f) p μ = eLpNorm f p (μ.restrict s)
|
simp_rw [hp_top, eLpNorm_exponent_top, eLpNormEssSup_eq_essSup_enorm,
enorm_indicator_eq_indicator_enorm, ENNReal.essSup_indicator_eq_essSup_restrict hs]
|
no goals
|
8446bfb6ebb65622
|
FormalMultilinearSeries.radius_rightInv_pos_of_radius_pos
|
Mathlib/Analysis/Analytic/Inverse.lean
|
theorem radius_rightInv_pos_of_radius_pos
{p : FormalMultilinearSeries 𝕜 E F} {i : E ≃L[𝕜] F} {x : E}
(hp : 0 < p.radius) : 0 < (p.rightInv i x).radius
|
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
x : E
hp : 0 < p.radius
C r : ℝ
Cpos : 0 < C
rpos : 0 < r
ple : ∀ (n : ℕ), ‖p n‖ ≤ C * r ^ n
I : ℝ := ‖↑i.symm‖
a : ℝ
apos : 0 < a
ha1 : 2 * I * C * r ^ 2 * (I + 1) ^ 2 * a ≤ 1
ha2 : r * (I + 1) * a ≤ 1 / 2
S : ℕ → ℝ := fun n => ∑ k ∈ Ico 1 n, a ^ k * ‖p.rightInv i x k‖
n : ℕ
one_le_n : 1 ≤ n
hn : S n ≤ (I + 1) * a
In : 2 ≤ n + 1
rSn : r * S n ≤ 1 / 2
⊢ r * S n ≠ 1
|
exact ne_of_lt (rSn.trans_lt (by norm_num))
|
no goals
|
8af3e9ca55cc3d57
|
ProbabilityTheory.measure_ge_le_exp_mul_mgf
|
Mathlib/Probability/Moments/Basic.lean
|
theorem measure_ge_le_exp_mul_mgf [IsFiniteMeasure μ] (ε : ℝ) (ht : 0 ≤ t)
(h_int : Integrable (fun ω => exp (t * X ω)) μ) :
(μ {ω | ε ≤ X ω}).toReal ≤ exp (-t * ε) * mgf X μ t
|
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
ε : ℝ
ht : 0 ≤ t
h_int : Integrable (fun ω => rexp (t * X ω)) μ
ht_pos : 0 < t
⊢ (μ {ω | rexp (t * ε) ≤ rexp (t * X ω)}).toReal ≤ (rexp (t * ε))⁻¹ * ∫ (x : Ω), (fun ω => rexp (t * X ω)) x ∂μ
|
have : exp (t * ε) * (μ {ω | exp (t * ε) ≤ exp (t * X ω)}).toReal ≤
μ[fun ω => exp (t * X ω)] :=
mul_meas_ge_le_integral_of_nonneg (ae_of_all _ fun x => (exp_pos _).le) h_int _
|
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
ε : ℝ
ht : 0 ≤ t
h_int : Integrable (fun ω => rexp (t * X ω)) μ
ht_pos : 0 < t
this : rexp (t * ε) * (μ {ω | rexp (t * ε) ≤ rexp (t * X ω)}).toReal ≤ ∫ (x : Ω), (fun ω => rexp (t * X ω)) x ∂μ
⊢ (μ {ω | rexp (t * ε) ≤ rexp (t * X ω)}).toReal ≤ (rexp (t * ε))⁻¹ * ∫ (x : Ω), (fun ω => rexp (t * X ω)) x ∂μ
|
d0b4656bb63daebb
|
Valuation.map_add_supp
|
Mathlib/RingTheory/Valuation/Basic.lean
|
theorem map_add_supp (a : R) {s : R} (h : s ∈ supp v) : v (a + s) = v a
|
R : Type u_3
Γ₀ : Type u_4
inst✝¹ : CommRing R
inst✝ : LinearOrderedCommMonoidWithZero Γ₀
v : Valuation R Γ₀
a s : R
h : s ∈ v.supp
aux : ∀ (a s : R), v s = 0 → v (a + s) ≤ v a
⊢ v a = v (a + s + -s)
|
simp
|
no goals
|
350be2a7ba39fca1
|
exists_isTranscendenceBasis'
|
Mathlib/RingTheory/AlgebraicIndependent/TranscendenceBasis.lean
|
theorem exists_isTranscendenceBasis' (R : Type u) {A : Type v} [CommRing R] [CommRing A]
[Algebra R A] (h : Injective (algebraMap R A)) :
∃ (ι : Type v) (x : ι → A), IsTranscendenceBasis R x
|
case intro
R : Type u
A : Type v
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
h✝ : Injective ⇑(algebraMap R A)
s : Set A
h : IsTranscendenceBasis R Subtype.val
⊢ ∃ ι x, IsTranscendenceBasis R x
|
exact ⟨s, Subtype.val, h⟩
|
no goals
|
db78d0e9bc9b1610
|
Besicovitch.TauPackage.color_lt
|
Mathlib/MeasureTheory/Covering/Besicovitch.lean
|
theorem color_lt {i : Ordinal.{u}} (hi : i < p.lastStep) {N : ℕ}
(hN : IsEmpty (SatelliteConfig α N p.τ)) : p.color i < N
|
case h
α : Type u_1
inst✝¹ : MetricSpace α
β : Type u
inst✝ : Nonempty β
p : TauPackage β α
N : ℕ
hN : IsEmpty (SatelliteConfig α N p.τ)
i : Ordinal.{u}
IH : ∀ k < i, k < p.lastStep → p.color k < N
hi : i < p.lastStep
⊢ p.color i < N
|
let A : Set ℕ :=
⋃ (j : { j // j < i })
(_ : (closedBall (p.c (p.index j)) (p.r (p.index j)) ∩
closedBall (p.c (p.index i)) (p.r (p.index i))).Nonempty),
{p.color j}
|
case h
α : Type u_1
inst✝¹ : MetricSpace α
β : Type u
inst✝ : Nonempty β
p : TauPackage β α
N : ℕ
hN : IsEmpty (SatelliteConfig α N p.τ)
i : Ordinal.{u}
IH : ∀ k < i, k < p.lastStep → p.color k < N
hi : i < p.lastStep
A : Set ℕ :=
⋃ j,
⋃ (_ :
(closedBall (p.c (p.index ↑j)) (p.r (p.index ↑j)) ∩ closedBall (p.c (p.index i)) (p.r (p.index i))).Nonempty),
{p.color ↑j}
⊢ p.color i < N
|
70d4d5d8aa8a7de2
|
HahnSeries.SummableFamily.pow_finite_co_support
|
Mathlib/RingTheory/HahnSeries/Summable.lean
|
theorem pow_finite_co_support {x : HahnSeries Γ R} (hx : 0 < x.orderTop) (g : Γ) :
Set.Finite {a | ((fun n ↦ x ^ n) a).coeff g ≠ 0}
|
Γ : Type u_1
R : Type u_3
inst✝¹ : LinearOrderedCancelAddCommMonoid Γ
inst✝ : CommRing R
x : HahnSeries Γ R
hx : 0 < x.orderTop
g : Γ
hpwo : (⋃ n, (x ^ n).support).IsPWO
⊢ {a | ((fun n => x ^ n) a).coeff g ≠ 0}.Finite
|
by_cases h0 : x = 0
|
case pos
Γ : Type u_1
R : Type u_3
inst✝¹ : LinearOrderedCancelAddCommMonoid Γ
inst✝ : CommRing R
x : HahnSeries Γ R
hx : 0 < x.orderTop
g : Γ
hpwo : (⋃ n, (x ^ n).support).IsPWO
h0 : x = 0
⊢ {a | ((fun n => x ^ n) a).coeff g ≠ 0}.Finite
case neg
Γ : Type u_1
R : Type u_3
inst✝¹ : LinearOrderedCancelAddCommMonoid Γ
inst✝ : CommRing R
x : HahnSeries Γ R
hx : 0 < x.orderTop
g : Γ
hpwo : (⋃ n, (x ^ n).support).IsPWO
h0 : ¬x = 0
⊢ {a | ((fun n => x ^ n) a).coeff g ≠ 0}.Finite
|
0868e21674511ec5
|
Cardinal.mk_perm_eq_self_power
|
Mathlib/SetTheory/Cardinal/Arithmetic.lean
|
theorem mk_perm_eq_self_power : #(Equiv.Perm α) = #α ^ #α :=
((mk_equiv_le_embedding α α).trans (mk_embedding_le_arrow α α)).antisymm <| by
suffices Nonempty ((α → Bool) ↪ Equiv.Perm (α × Bool)) by
obtain ⟨e⟩ : Nonempty (α ≃ α × Bool)
|
α : Type u
inst✝ : Infinite α
⊢ Nonempty ((α → Bool) ↪ Perm (α × Bool))
|
refine ⟨⟨fun f ↦ Involutive.toPerm (fun x ↦ ⟨x.1, xor (f x.1) x.2⟩) fun x ↦ ?_, fun f g h ↦ ?_⟩⟩
|
case refine_1
α : Type u
inst✝ : Infinite α
f : α → Bool
x : α × Bool
⊢ (fun x => (x.1, f x.1 ^^ x.2)) ((fun x => (x.1, f x.1 ^^ x.2)) x) = x
case refine_2
α : Type u
inst✝ : Infinite α
f g : α → Bool
h :
(fun f => Involutive.toPerm (fun x => (x.1, f x.1 ^^ x.2)) ⋯) f =
(fun f => Involutive.toPerm (fun x => (x.1, f x.1 ^^ x.2)) ⋯) g
⊢ f = g
|
22b0a13df4d7f440
|
FiniteField.trace_to_zmod_nondegenerate
|
Mathlib/FieldTheory/Finite/Trace.lean
|
theorem trace_to_zmod_nondegenerate (F : Type*) [Field F] [Finite F]
[Algebra (ZMod (ringChar F)) F] {a : F} (ha : a ≠ 0) :
∃ b : F, Algebra.trace (ZMod (ringChar F)) F (a * b) ≠ 0
|
F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : Algebra (ZMod (ringChar F)) F
a : F
ha : a ≠ 0
this : Fact (Nat.Prime (ringChar F))
⊢ ∃ b, (Algebra.trace (ZMod (ringChar F)) F) (a * b) ≠ 0
|
have htr := traceForm_nondegenerate (ZMod (ringChar F)) F a
|
F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : Algebra (ZMod (ringChar F)) F
a : F
ha : a ≠ 0
this : Fact (Nat.Prime (ringChar F))
htr : (∀ (n : F), ((Algebra.traceForm (ZMod (ringChar F)) F) a) n = 0) → a = 0
⊢ ∃ b, (Algebra.trace (ZMod (ringChar F)) F) (a * b) ≠ 0
|
94745db3858cfcfe
|
Finset.prod_add_prod_le
|
Mathlib/Algebra/Order/BigOperators/Ring/Finset.lean
|
/-- If `g, h ≤ f` and `g i + h i ≤ f i`, then the product of `f` over `s` is at least the
sum of the products of `g` and `h`. This is the version for `OrderedCommSemiring`. -/
lemma prod_add_prod_le {i : ι} {f g h : ι → R} (hi : i ∈ s) (h2i : g i + h i ≤ f i)
(hgf : ∀ j ∈ s, j ≠ i → g j ≤ f j) (hhf : ∀ j ∈ s, j ≠ i → h j ≤ f j) (hg : ∀ i ∈ s, 0 ≤ g i)
(hh : ∀ i ∈ s, 0 ≤ h i) : ((∏ i ∈ s, g i) + ∏ i ∈ s, h i) ≤ ∏ i ∈ s, f i
|
ι : Type u_1
R : Type u_2
inst✝ : OrderedCommSemiring R
s : Finset ι
i : ι
f g h : ι → R
hi : i ∈ s
h2i : g i + h i ≤ f i
hgf : ∀ j ∈ s, j ≠ i → g j ≤ f j
hhf : ∀ j ∈ s, j ≠ i → h j ≤ f j
hg : ∀ i ∈ s, 0 ≤ g i
hh : ∀ i ∈ s, 0 ≤ h i
⊢ ∏ i ∈ s, g i + ∏ i ∈ s, h i ≤ ∏ i ∈ s, f i
|
simp_rw [prod_eq_mul_prod_diff_singleton hi]
|
ι : Type u_1
R : Type u_2
inst✝ : OrderedCommSemiring R
s : Finset ι
i : ι
f g h : ι → R
hi : i ∈ s
h2i : g i + h i ≤ f i
hgf : ∀ j ∈ s, j ≠ i → g j ≤ f j
hhf : ∀ j ∈ s, j ≠ i → h j ≤ f j
hg : ∀ i ∈ s, 0 ≤ g i
hh : ∀ i ∈ s, 0 ≤ h i
⊢ g i * ∏ i ∈ s \ {i}, g i + h i * ∏ i ∈ s \ {i}, h i ≤ f i * ∏ i ∈ s \ {i}, f i
|
81f5bc6d2c853439
|
RingHom.Flat.isStableUnderBaseChange
|
Mathlib/RingTheory/RingHom/Flat.lean
|
lemma isStableUnderBaseChange : IsStableUnderBaseChange Flat
|
case h.e'_5.h.h.e_5.h.h
R S T : Type u_4
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : CommRing T
inst✝¹ : Algebra R S
inst✝ : Algebra R T
h : Module.Flat R T
this : Module.Flat S (S ⊗[R] T)
e_4✝ : NonUnitalNonAssocSemiring.toAddCommMonoid = addCommMonoid
r✝ : S
x✝ : S ⊗[R] T
⊢ (algebraMap S (S ⊗[R] T)) r✝ * x✝ = (algebraMap S (S ⊗[R] T)) r✝ * x✝
|
rfl
|
no goals
|
de2a47f537ad5f13
|
IsMulFreimanIso.mono
|
Mathlib/Combinatorics/Additive/FreimanHom.lean
|
@[to_additive]
lemma IsMulFreimanIso.mono {hmn : m ≤ n} (hf : IsMulFreimanIso n A B f) :
IsMulFreimanIso m A B f where
bijOn := hf.bijOn
map_prod_eq_map_prod s t hsA htA hs ht
|
case inr.intro.refine_1
α : Type u_2
β : Type u_3
inst✝¹ : CancelCommMonoid α
inst✝ : CancelCommMonoid β
A : Set α
B : Set β
f : α → β
m n : ℕ
hmn : m ≤ n
hf : IsMulFreimanIso n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : s.card = m
ht : t.card = m
a✝ : α
ha✝ : a✝ ∈ A
a : α
ha : a ∈ s ∨ a ∈ replicate (n - m) a✝
⊢ a ∈ A
|
obtain ha | ha := ha
|
case inr.intro.refine_1.inl
α : Type u_2
β : Type u_3
inst✝¹ : CancelCommMonoid α
inst✝ : CancelCommMonoid β
A : Set α
B : Set β
f : α → β
m n : ℕ
hmn : m ≤ n
hf : IsMulFreimanIso n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : s.card = m
ht : t.card = m
a✝ : α
ha✝ : a✝ ∈ A
a : α
ha : a ∈ s
⊢ a ∈ A
case inr.intro.refine_1.inr
α : Type u_2
β : Type u_3
inst✝¹ : CancelCommMonoid α
inst✝ : CancelCommMonoid β
A : Set α
B : Set β
f : α → β
m n : ℕ
hmn : m ≤ n
hf : IsMulFreimanIso n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : s.card = m
ht : t.card = m
a✝ : α
ha✝ : a✝ ∈ A
a : α
ha : a ∈ replicate (n - m) a✝
⊢ a ∈ A
|
4d38848292c1597f
|
Polynomial.eval_comp
|
Mathlib/Algebra/Polynomial/Eval/Defs.lean
|
theorem eval_comp : (p.comp q).eval x = p.eval (q.eval x)
|
case h_monomial
R : Type u
inst✝ : CommSemiring R
p q : R[X]
x : R
n : ℕ
a : R
⊢ eval x (((monomial n) a).comp q) = eval (eval x q) ((monomial n) a)
|
simp
|
no goals
|
89083fc25576ec15
|
cfcₙ_integral
|
Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Integral.lean
|
/-- The non-unital continuous functional calculus commutes with integration. -/
lemma cfcₙ_integral [TopologicalSpace X] [OpensMeasurableSpace X] (f : X → 𝕜 → 𝕜)
(bound : X → ℝ) (a : A) [SecondCountableTopologyEither X C(quasispectrum 𝕜 a, 𝕜)₀]
(hf₁ : ∀ x, ContinuousOn (f x) (quasispectrum 𝕜 a))
(hf₂ : ∀ x, f x 0 = 0)
(hf₃ : Continuous (fun x ↦ (⟨⟨_, hf₁ x |>.restrict⟩, hf₂ x⟩ : C(quasispectrum 𝕜 a, 𝕜)₀)))
(hbound : ∀ x, ∀ z ∈ quasispectrum 𝕜 a, ‖f x z‖ ≤ ‖bound x‖)
(hbound_finite_integral : HasFiniteIntegral bound μ) (ha : p a
|
X : Type u_1
𝕜 : Type u_2
A : Type u_3
p : A → Prop
inst✝¹² : RCLike 𝕜
inst✝¹¹ : MeasurableSpace X
μ : Measure X
inst✝¹⁰ : NonUnitalNormedRing A
inst✝⁹ : StarRing A
inst✝⁸ : CompleteSpace A
inst✝⁷ : NormedSpace 𝕜 A
inst✝⁶ : NormedSpace ℝ A
inst✝⁵ : IsScalarTower 𝕜 A A
inst✝⁴ : SMulCommClass 𝕜 A A
inst✝³ : NonUnitalContinuousFunctionalCalculus 𝕜 p
inst✝² : TopologicalSpace X
inst✝¹ : OpensMeasurableSpace X
f : X → 𝕜 → 𝕜
bound : X → ℝ
a : A
inst✝ : SecondCountableTopologyEither X C(↑(quasispectrum 𝕜 a), 𝕜)₀
hf₁ : ∀ (x : X), ContinuousOn (f x) (quasispectrum 𝕜 a)
hf₂ : ∀ (x : X), f x 0 = 0
hf₃ : Continuous fun x => { toFun := (quasispectrum 𝕜 a).restrict (f x), continuous_toFun := ⋯, map_zero' := ⋯ }
hbound : ∀ (x : X), ∀ z ∈ quasispectrum 𝕜 a, ‖f x z‖ ≤ ‖bound x‖
hbound_finite_integral : HasFiniteIntegral bound μ
ha : autoParam (p a) _auto✝
fc : X → C(↑(quasispectrum 𝕜 a), 𝕜)₀ :=
fun x => { toFun := (quasispectrum 𝕜 a).restrict (f x), continuous_toFun := ⋯, map_zero' := ⋯ }
x : X
⊢ ‖fc x‖ ≤ ‖bound x‖
|
change ‖(fc x : C(quasispectrum 𝕜 a, 𝕜))‖ ≤ ‖bound x‖
|
X : Type u_1
𝕜 : Type u_2
A : Type u_3
p : A → Prop
inst✝¹² : RCLike 𝕜
inst✝¹¹ : MeasurableSpace X
μ : Measure X
inst✝¹⁰ : NonUnitalNormedRing A
inst✝⁹ : StarRing A
inst✝⁸ : CompleteSpace A
inst✝⁷ : NormedSpace 𝕜 A
inst✝⁶ : NormedSpace ℝ A
inst✝⁵ : IsScalarTower 𝕜 A A
inst✝⁴ : SMulCommClass 𝕜 A A
inst✝³ : NonUnitalContinuousFunctionalCalculus 𝕜 p
inst✝² : TopologicalSpace X
inst✝¹ : OpensMeasurableSpace X
f : X → 𝕜 → 𝕜
bound : X → ℝ
a : A
inst✝ : SecondCountableTopologyEither X C(↑(quasispectrum 𝕜 a), 𝕜)₀
hf₁ : ∀ (x : X), ContinuousOn (f x) (quasispectrum 𝕜 a)
hf₂ : ∀ (x : X), f x 0 = 0
hf₃ : Continuous fun x => { toFun := (quasispectrum 𝕜 a).restrict (f x), continuous_toFun := ⋯, map_zero' := ⋯ }
hbound : ∀ (x : X), ∀ z ∈ quasispectrum 𝕜 a, ‖f x z‖ ≤ ‖bound x‖
hbound_finite_integral : HasFiniteIntegral bound μ
ha : autoParam (p a) _auto✝
fc : X → C(↑(quasispectrum 𝕜 a), 𝕜)₀ :=
fun x => { toFun := (quasispectrum 𝕜 a).restrict (f x), continuous_toFun := ⋯, map_zero' := ⋯ }
x : X
⊢ ‖↑(fc x)‖ ≤ ‖bound x‖
|
c8ceb0f73ee7838a
|
DenseRange.topologicalClosure_map_subgroup
|
Mathlib/Topology/Algebra/Group/Basic.lean
|
theorem DenseRange.topologicalClosure_map_subgroup [Group H] [TopologicalSpace H]
[IsTopologicalGroup H] {f : G →* H} (hf : Continuous f) (hf' : DenseRange f) {s : Subgroup G}
(hs : s.topologicalClosure = ⊤) : (s.map f).topologicalClosure = ⊤
|
G : Type w
H : Type x
inst✝⁵ : TopologicalSpace G
inst✝⁴ : Group G
inst✝³ : IsTopologicalGroup G
inst✝² : Group H
inst✝¹ : TopologicalSpace H
inst✝ : IsTopologicalGroup H
f : G →* H
hf : Continuous ⇑f
hf' : DenseRange ⇑f
s : Subgroup G
hs : s.topologicalClosure = ⊤
⊢ (Subgroup.map f s).topologicalClosure = ⊤
|
rw [SetLike.ext'_iff] at hs ⊢
|
G : Type w
H : Type x
inst✝⁵ : TopologicalSpace G
inst✝⁴ : Group G
inst✝³ : IsTopologicalGroup G
inst✝² : Group H
inst✝¹ : TopologicalSpace H
inst✝ : IsTopologicalGroup H
f : G →* H
hf : Continuous ⇑f
hf' : DenseRange ⇑f
s : Subgroup G
hs : ↑s.topologicalClosure = ↑⊤
⊢ ↑(Subgroup.map f s).topologicalClosure = ↑⊤
|
b2d3347c9216c0a5
|
IntermediateField.exists_algHom_adjoin_of_splits
|
Mathlib/FieldTheory/Extension.lean
|
theorem exists_algHom_adjoin_of_splits : ∃ φ : adjoin F S →ₐ[F] K, φ.comp (inclusion hL) = f
|
case intro.intro.refine_2
F : Type u_1
E : Type u_2
K : Type u_3
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Field K
inst✝¹ : Algebra F E
inst✝ : Algebra F K
S : Set E
hK : ∀ s ∈ S, IsIntegral F s ∧ Splits (algebraMap F K) (minpoly F s)
L : IntermediateField F E
f : ↥L →ₐ[F] K
hL : L ≤ adjoin F S
φ : Lifts F E K
hfφ : { carrier := L, emb := f } ≤ φ
hφ : IsMax φ
⊢ (φ.emb.comp (inclusion ⋯)).comp (inclusion hL) = f
|
ext
|
case intro.intro.refine_2.H
F : Type u_1
E : Type u_2
K : Type u_3
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Field K
inst✝¹ : Algebra F E
inst✝ : Algebra F K
S : Set E
hK : ∀ s ∈ S, IsIntegral F s ∧ Splits (algebraMap F K) (minpoly F s)
L : IntermediateField F E
f : ↥L →ₐ[F] K
hL : L ≤ adjoin F S
φ : Lifts F E K
hfφ : { carrier := L, emb := f } ≤ φ
hφ : IsMax φ
x✝ : ↥L
⊢ ((φ.emb.comp (inclusion ⋯)).comp (inclusion hL)) x✝ = f x✝
|
8633288b622106c6
|
Linarith.lt_of_eq_of_lt
|
Mathlib/Tactic/Linarith/Lemmas.lean
|
theorem lt_of_eq_of_lt {α} [OrderedSemiring α] {a b : α} (ha : a = 0) (hb : b < 0) : a + b < 0
|
α : Type u_1
inst✝ : OrderedSemiring α
a b : α
ha : a = 0
hb : b < 0
⊢ a + b < 0
|
simp [*]
|
no goals
|
f1d12b3ca07ba69a
|
AkraBazziRecurrence.GrowsPolynomially.zpow
|
Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
|
protected lemma GrowsPolynomially.zpow (p : ℤ) (hf : GrowsPolynomially f)
(hf_nonneg : ∀ᶠ x in atTop, 0 ≤ f x) : GrowsPolynomially fun x => (f x) ^ p
|
f : ℝ → ℝ
p : ℤ
hf : GrowsPolynomially f
hf_nonneg : ∀ᶠ (x : ℝ) in atTop, 0 ≤ f x
⊢ GrowsPolynomially fun x => f x ^ p
|
simp_rw [← rpow_intCast]
|
f : ℝ → ℝ
p : ℤ
hf : GrowsPolynomially f
hf_nonneg : ∀ᶠ (x : ℝ) in atTop, 0 ≤ f x
⊢ GrowsPolynomially fun x => f x ^ ↑p
|
35ea835a985445c9
|
Filter.prod_principal_principal
|
Mathlib/Order/Filter/Prod.lean
|
theorem prod_principal_principal {s : Set α} {t : Set β} : 𝓟 s ×ˢ 𝓟 t = 𝓟 (s ×ˢ t)
|
α : Type u_1
β : Type u_2
s : Set α
t : Set β
⊢ Prod.fst ⁻¹' s ∩ Prod.snd ⁻¹' t = s ×ˢ t
|
rfl
|
no goals
|
198a598179b7f1b6
|
isTopologicalBasis_isClopen
|
Mathlib/Topology/Separation/Profinite.lean
|
theorem isTopologicalBasis_isClopen : IsTopologicalBasis { s : Set X | IsClopen s }
|
X : Type u_1
inst✝³ : TopologicalSpace X
inst✝² : T2Space X
inst✝¹ : CompactSpace X
inst✝ : TotallyDisconnectedSpace X
⊢ ∀ (a : X) (u : Set X), a ∈ u → IsOpen u → ∃ v ∈ fun U => IsClosed U ∧ IsOpen U, a ∈ v ∧ v ⊆ u
|
intro x U hxU U_op
|
X : Type u_1
inst✝³ : TopologicalSpace X
inst✝² : T2Space X
inst✝¹ : CompactSpace X
inst✝ : TotallyDisconnectedSpace X
x : X
U : Set X
hxU : x ∈ U
U_op : IsOpen U
⊢ ∃ v ∈ fun U => IsClosed U ∧ IsOpen U, x ∈ v ∧ v ⊆ U
|
794664f79b6f2170
|
ProbabilityTheory.Kernel.IndepSets.union
|
Mathlib/Probability/Independence/Kernel.lean
|
theorem IndepSets.union {s₁ s₂ s' : Set (Set Ω)} {_mΩ : MeasurableSpace Ω}
{κ : Kernel α Ω} {μ : Measure α}
(h₁ : IndepSets s₁ s' κ μ) (h₂ : IndepSets s₂ s' κ μ) :
IndepSets (s₁ ∪ s₂) s' κ μ
|
case inr
α : Type u_1
Ω : Type u_2
_mα : MeasurableSpace α
s₁ s₂ s' : Set (Set Ω)
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
h₁ : IndepSets s₁ s' κ μ
h₂ : IndepSets s₂ s' κ μ
t1 t2 : Set Ω
ht1 : t1 ∈ s₁ ∪ s₂
ht2 : t2 ∈ s'
ht1₂ : t1 ∈ s₂
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (t1 ∩ t2) = (κ a) t1 * (κ a) t2
|
exact h₂ t1 t2 ht1₂ ht2
|
no goals
|
ae105d1947c977e0
|
FirstOrder.Ring.realize_termOfFreeCommRing
|
Mathlib/ModelTheory/Algebra/Ring/FreeCommRing.lean
|
theorem realize_termOfFreeCommRing (p : FreeCommRing α) (v : α → R) :
(termOfFreeCommRing p).realize v = FreeCommRing.lift v p
|
case var
α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
x✝ : CompatibleRing (FreeCommRing α) := compatibleRingOfRing (FreeCommRing α)
a✝ : α
⊢ Term.realize v (var a✝) = (FreeCommRing.lift v) (Term.realize FreeCommRing.of (var a✝))
|
simp
|
no goals
|
01caeeaee92420b9
|
MvPowerSeries.coeff_mul_of_add_lexOrder
|
Mathlib/RingTheory/MvPowerSeries/LexOrder.lean
|
theorem coeff_mul_of_add_lexOrder {φ ψ : MvPowerSeries σ R}
{p q : σ →₀ ℕ} (hp : lexOrder φ = toLex p) (hq : lexOrder ψ = toLex q) :
coeff R (p + q) (φ * ψ) = coeff R p φ * coeff R q ψ
|
case pos
σ : Type u_1
R : Type u_2
inst✝² : Semiring R
inst✝¹ : LinearOrder σ
inst✝ : WellFoundedGT σ
φ ψ : MvPowerSeries σ R
p q : σ →₀ ℕ
hp : φ.lexOrder = ↑(toLex p)
hq : ψ.lexOrder = ↑(toLex q)
u v : σ →₀ ℕ
h' : (u, v) ≠ (p, q)
h : u + v = p + q
hu : toLex u < toLex p
⊢ ↑(toLex u) < φ.lexOrder
|
simp only [hp, WithTop.coe_lt_coe, hu]
|
no goals
|
0c23704cc23b543a
|
Std.Sat.AIG.denote_relabel
|
Mathlib/.lake/packages/lean4/src/lean/Std/Sat/AIG/Relabel.lean
|
theorem denote_relabel (aig : AIG α) (r : α → β) (start : Nat) {hidx}
(assign : β → Bool) :
⟦aig.relabel r, ⟨start, hidx⟩, assign⟧
=
⟦aig, ⟨start, by rw [← relabel_size_eq_size (r := r)]; omega⟩, (assign ∘ r)⟧
|
α : Type
inst✝³ : Hashable α
inst✝² : DecidableEq α
β : Type
inst✝¹ : Hashable β
inst✝ : DecidableEq β
aig : AIG α
r : α → β
start : Nat
hidx : start < (relabel r aig).decls.size
assign : β → Bool
⊢ start < aig.decls.size
|
rw [← relabel_size_eq_size (r := r)]
|
α : Type
inst✝³ : Hashable α
inst✝² : DecidableEq α
β : Type
inst✝¹ : Hashable β
inst✝ : DecidableEq β
aig : AIG α
r : α → β
start : Nat
hidx : start < (relabel r aig).decls.size
assign : β → Bool
⊢ start < (relabel r aig).decls.size
|
cbc1035eea40fc57
|
Std.DHashMap.Internal.AssocList.Const.toList_alter
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/AssocList/Lemmas.lean
|
theorem toList_alter [BEq α] [EquivBEq α] {a : α} {f : Option β → Option β}
{l : AssocList α (fun _ => β)} : Perm (alter a f l).toList (Const.alterKey a f l.toList)
|
case cons
α : Type u
β : Type v
inst✝¹ : BEq α
inst✝ : EquivBEq α
a : α
f : Option β → Option β
key✝ : α
value✝ : β
tail✝ : AssocList α fun x => β
tail_ih✝ : (alter a f tail✝).toList.Perm (Const.alterKey a f tail✝.toList)
⊢ (alter a f (cons key✝ value✝ tail✝)).toList.Perm
(if (key✝ == a) = true then
match f (some value✝) with
| none => tail✝.toList
| some v => ⟨a, v⟩ :: tail✝.toList
else ⟨key✝, value✝⟩ :: Const.alterKey a f tail✝.toList)
|
rw [alter]
|
case cons
α : Type u
β : Type v
inst✝¹ : BEq α
inst✝ : EquivBEq α
a : α
f : Option β → Option β
key✝ : α
value✝ : β
tail✝ : AssocList α fun x => β
tail_ih✝ : (alter a f tail✝).toList.Perm (Const.alterKey a f tail✝.toList)
⊢ (if (key✝ == a) = true then
match f (some value✝) with
| none => tail✝
| some b => cons a b tail✝
else
let tail := alter a f tail✝;
cons key✝ value✝ tail).toList.Perm
(if (key✝ == a) = true then
match f (some value✝) with
| none => tail✝.toList
| some v => ⟨a, v⟩ :: tail✝.toList
else ⟨key✝, value✝⟩ :: Const.alterKey a f tail✝.toList)
|
ede47393f817204a
|
DihedralGroup.exponent
|
Mathlib/GroupTheory/SpecificGroups/Dihedral.lean
|
theorem exponent : Monoid.exponent (DihedralGroup n) = lcm n 2
|
case inr.a.a.r
n : ℕ
hn : NeZero n
m : ZMod n
⊢ r m ^ lcm n 2 = 1
|
rw [← orderOf_dvd_iff_pow_eq_one, orderOf_r]
|
case inr.a.a.r
n : ℕ
hn : NeZero n
m : ZMod n
⊢ n / n.gcd m.val ∣ lcm n 2
|
5619adb1153445d8
|
smoothSheafCommRing.isUnit_stalk_iff
|
Mathlib/Geometry/Manifold/Sheaf/LocallyRingedSpace.lean
|
theorem smoothSheafCommRing.isUnit_stalk_iff {x : M}
(f : (smoothSheafCommRing IM 𝓘(𝕜) M 𝕜).presheaf.stalk x) :
IsUnit f ↔ f ∉ RingHom.ker (smoothSheafCommRing.eval IM 𝓘(𝕜) M 𝕜 x)
|
case mpr.intro.intro.intro
𝕜 : Type u
inst✝⁵ : NontriviallyNormedField 𝕜
EM : Type u_1
inst✝⁴ : NormedAddCommGroup EM
inst✝³ : NormedSpace 𝕜 EM
HM : Type u_2
inst✝² : TopologicalSpace HM
IM : ModelWithCorners 𝕜 EM HM
M : Type u
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace HM M
x : M
S : TopCat.Presheaf CommRingCat (TopCat.of M) := (smoothSheafCommRing IM 𝓘(𝕜, 𝕜) M 𝕜).presheaf
U : Opens M
hxU : x ∈ U
f : C^∞⟮IM, ↥U; 𝓘(𝕜, 𝕜), 𝕜⟯
hf : (eval IM 𝓘(𝕜, 𝕜) M 𝕜 x) ((CategoryTheory.ConcreteCategory.hom (S.germ U x hxU)) f) ≠ 0
hf' : f ⟨x, hxU⟩ ≠ 0
⊢ IsUnit ((CategoryTheory.ConcreteCategory.hom (S.germ U x hxU)) f)
|
have H : ∀ᶠ (z : U) in 𝓝 ⟨x, hxU⟩, f z ≠ 0 := f.2.continuous.continuousAt.eventually_ne hf'
|
case mpr.intro.intro.intro
𝕜 : Type u
inst✝⁵ : NontriviallyNormedField 𝕜
EM : Type u_1
inst✝⁴ : NormedAddCommGroup EM
inst✝³ : NormedSpace 𝕜 EM
HM : Type u_2
inst✝² : TopologicalSpace HM
IM : ModelWithCorners 𝕜 EM HM
M : Type u
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace HM M
x : M
S : TopCat.Presheaf CommRingCat (TopCat.of M) := (smoothSheafCommRing IM 𝓘(𝕜, 𝕜) M 𝕜).presheaf
U : Opens M
hxU : x ∈ U
f : C^∞⟮IM, ↥U; 𝓘(𝕜, 𝕜), 𝕜⟯
hf : (eval IM 𝓘(𝕜, 𝕜) M 𝕜 x) ((CategoryTheory.ConcreteCategory.hom (S.germ U x hxU)) f) ≠ 0
hf' : f ⟨x, hxU⟩ ≠ 0
H : ∀ᶠ (z : ↥U) in 𝓝 ⟨x, hxU⟩, f z ≠ 0
⊢ IsUnit ((CategoryTheory.ConcreteCategory.hom (S.germ U x hxU)) f)
|
f7ca29d724eff4f4
|
FractionalIdeal.mul_right_mono
|
Mathlib/RingTheory/FractionalIdeal/Basic.lean
|
theorem mul_right_mono (I : FractionalIdeal S P) : Monotone fun J => J * I
|
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
I J J' : FractionalIdeal S P
h : J ≤ J'
⊢ ⟨↑J * ↑I, ⋯⟩ ≤ ⟨↑J' * ↑I, ⋯⟩
|
exact mul_le.mpr fun x hx y hy => mul_mem_mul (h hx) hy
|
no goals
|
4b4fbc796ff3929f
|
Fermat42.not_minimal
|
Mathlib/NumberTheory/FLT/Four.lean
|
theorem not_minimal {a b c : ℤ} (h : Minimal a b c) (ha2 : a % 2 = 1) (hc : 0 < c) : False
|
a b c : ℤ
h : Minimal a b c
ha2 : a % 2 = 1
hc : 0 < c
ht : PythagoreanTriple (a ^ 2) (b ^ 2) c
h2 : (a ^ 2).gcd (b ^ 2) = 1
ha22 : a ^ 2 % 2 = 1
m n : ℤ
ht1 : a ^ 2 = m ^ 2 - n ^ 2
ht2 : b ^ 2 = 2 * m * n
ht3 : c = m ^ 2 + n ^ 2
ht4 : m.gcd n = 1
ht5 : m % 2 = 0 ∧ n % 2 = 1 ∨ m % 2 = 1 ∧ n % 2 = 0
ht6 : 0 ≤ m
htt : PythagoreanTriple a n m
h3 : a.gcd n = 1
hb20 : b ^ 2 ≠ 0
h4 : 0 < m
r s : ℤ
left✝ : a = r ^ 2 - s ^ 2
htt2 : n = 2 * r * s
htt3 : m = r ^ 2 + s ^ 2
htt4 : r.gcd s = 1
htt5 : r % 2 = 0 ∧ s % 2 = 1 ∨ r % 2 = 1 ∧ s % 2 = 0
htt6 : 0 ≤ r
hcp : m.gcd (r * s) = 1
b' : ℤ
hb2' : b = 2 * b'
hs : b' ^ 2 = m * (r * s)
hrsz : r * s ≠ 0
h2b0 : b' ≠ 0
i : ℤ
hi : m = i ^ 2 ∨ m = -i ^ 2
h1 : m = -i ^ 2
⊢ False
|
have hit : -i ^ 2 ≤ 0 := neg_nonpos.mpr (sq_nonneg i)
|
a b c : ℤ
h : Minimal a b c
ha2 : a % 2 = 1
hc : 0 < c
ht : PythagoreanTriple (a ^ 2) (b ^ 2) c
h2 : (a ^ 2).gcd (b ^ 2) = 1
ha22 : a ^ 2 % 2 = 1
m n : ℤ
ht1 : a ^ 2 = m ^ 2 - n ^ 2
ht2 : b ^ 2 = 2 * m * n
ht3 : c = m ^ 2 + n ^ 2
ht4 : m.gcd n = 1
ht5 : m % 2 = 0 ∧ n % 2 = 1 ∨ m % 2 = 1 ∧ n % 2 = 0
ht6 : 0 ≤ m
htt : PythagoreanTriple a n m
h3 : a.gcd n = 1
hb20 : b ^ 2 ≠ 0
h4 : 0 < m
r s : ℤ
left✝ : a = r ^ 2 - s ^ 2
htt2 : n = 2 * r * s
htt3 : m = r ^ 2 + s ^ 2
htt4 : r.gcd s = 1
htt5 : r % 2 = 0 ∧ s % 2 = 1 ∨ r % 2 = 1 ∧ s % 2 = 0
htt6 : 0 ≤ r
hcp : m.gcd (r * s) = 1
b' : ℤ
hb2' : b = 2 * b'
hs : b' ^ 2 = m * (r * s)
hrsz : r * s ≠ 0
h2b0 : b' ≠ 0
i : ℤ
hi : m = i ^ 2 ∨ m = -i ^ 2
h1 : m = -i ^ 2
hit : -i ^ 2 ≤ 0
⊢ False
|
58647b498e4824ae
|
Nat.bitIndices_two_mul_add_one
|
Mathlib/Data/Nat/BitIndices.lean
|
theorem bitIndices_two_mul_add_one (n : ℕ) :
bitIndices (2 * n + 1) = 0 :: (bitIndices n).map (· + 1)
|
n : ℕ
⊢ (2 * n + 1).bitIndices = 0 :: map (fun x => x + 1) n.bitIndices
|
rw [← bitIndices_bit_true, bit_true]
|
no goals
|
7c3ae968fa7095e7
|
tendsto_of_le_liminf_of_limsup_le
|
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
theorem tendsto_of_le_liminf_of_limsup_le {f : Filter β} {u : β → α} {a : α} (hinf : a ≤ liminf u f)
(hsup : limsup u f ≤ a) (h : f.IsBoundedUnder (· ≤ ·) u
|
case inl
α : Type u_2
β : Type u_3
inst✝² : ConditionallyCompleteLinearOrder α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
u : β → α
a : α
hinf : a ≤ liminf u ⊥
hsup : limsup u ⊥ ≤ a
h : autoParam (IsBoundedUnder (fun x1 x2 => x1 ≤ x2) ⊥ u) _auto✝
h' : autoParam (IsBoundedUnder (fun x1 x2 => x1 ≥ x2) ⊥ u) _auto✝
⊢ Tendsto u ⊥ (𝓝 a)
|
exact tendsto_bot
|
no goals
|
b5c733a89e70f693
|
exists_isIntegralCurveAt_of_contMDiffAt
|
Mathlib/Geometry/Manifold/IntegralCurve/ExistUnique.lean
|
theorem exists_isIntegralCurveAt_of_contMDiffAt [CompleteSpace E]
(hv : ContMDiffAt I I.tangent 1 (fun x ↦ (⟨x, v x⟩ : TangentBundle I M)) x₀)
(hx : I.IsInteriorPoint x₀) :
∃ γ : ℝ → M, γ t₀ = x₀ ∧ IsIntegralCurveAt γ v t₀
|
case intro.intro.intro.intro.intro
E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
H : Type u_2
inst✝⁴ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
inst✝¹ : IsManifold I 1 M
v : (x : M) → TangentSpace I x
t₀ : ℝ
x₀ : M
inst✝ : CompleteSpace E
hx : I.IsInteriorPoint x₀
left✝ : ContinuousAt (fun x => { proj := x, snd := v x }) x₀
hv :
ContDiffWithinAt ℝ 1
(↑(extChartAt I.tangent { proj := x₀, snd := v x₀ }) ∘
(fun x => { proj := x, snd := v x }) ∘ ↑(extChartAt I x₀).symm)
(range ↑I) (↑(extChartAt I x₀) x₀)
f : ℝ → E
hf1 : f t₀ = ↑(extChartAt I x₀) x₀
hf2 :
∀ᶠ (y : ℝ) in 𝓝 t₀,
HasDerivAt f
((↑(extChartAt I.tangent { proj := x₀, snd := v x₀ }) ∘
(fun x => { proj := x, snd := v x }) ∘ ↑(extChartAt I x₀).symm)
(f y)).2
y
a : ℝ
ha : a > 0
hf2' :
∀ y ∈ Metric.ball t₀ a,
HasDerivAt f
((↑(extChartAt I.tangent { proj := x₀, snd := v x₀ }) ∘
(fun x => { proj := x, snd := v x }) ∘ ↑(extChartAt I x₀).symm)
(f y)).2
y
hcont : ∀ A ∈ 𝓝 (↑(extChartAt I x₀) x₀), f ⁻¹' A ∈ 𝓝 t₀
hnhds : ∀ᶠ (x' : ℝ) in 𝓝 t₀, f ⁻¹' interior (extChartAt I x₀).target ∈ 𝓝 x'
s : Set ℝ
hs : s ∈ 𝓝 t₀
haux :
∀ y ∈ s,
HasDerivAt f
((↑(extChartAt I.tangent { proj := x₀, snd := v x₀ }) ∘
(fun x => { proj := x, snd := v x }) ∘ ↑(extChartAt I x₀).symm)
(f y)).2
y ∧
f ⁻¹' interior (extChartAt I x₀).target ∈ 𝓝 y
t : ℝ
ht : t ∈ s
xₜ : M := ↑(extChartAt I x₀).symm (f t)
h : HasDerivAt f ((tangentCoordChange I xₜ x₀ xₜ) (v xₜ)) t
hf3 : f t ∈ interior (extChartAt I x₀).target
hf3' : f t ∈ (extChartAt I x₀).target
hft1 : ↑(extChartAt I x₀).symm (f t) ∈ (extChartAt I x₀).source
⊢ HasMFDerivAt (modelWithCornersSelf ℝ ℝ) I (↑(extChartAt I x₀).symm ∘ f) t
(ContinuousLinearMap.smulRight 1 (v ((↑(extChartAt I x₀).symm ∘ f) t)))
|
have hft2 := mem_extChartAt_source (I := I) xₜ
|
case intro.intro.intro.intro.intro
E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
H : Type u_2
inst✝⁴ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
inst✝¹ : IsManifold I 1 M
v : (x : M) → TangentSpace I x
t₀ : ℝ
x₀ : M
inst✝ : CompleteSpace E
hx : I.IsInteriorPoint x₀
left✝ : ContinuousAt (fun x => { proj := x, snd := v x }) x₀
hv :
ContDiffWithinAt ℝ 1
(↑(extChartAt I.tangent { proj := x₀, snd := v x₀ }) ∘
(fun x => { proj := x, snd := v x }) ∘ ↑(extChartAt I x₀).symm)
(range ↑I) (↑(extChartAt I x₀) x₀)
f : ℝ → E
hf1 : f t₀ = ↑(extChartAt I x₀) x₀
hf2 :
∀ᶠ (y : ℝ) in 𝓝 t₀,
HasDerivAt f
((↑(extChartAt I.tangent { proj := x₀, snd := v x₀ }) ∘
(fun x => { proj := x, snd := v x }) ∘ ↑(extChartAt I x₀).symm)
(f y)).2
y
a : ℝ
ha : a > 0
hf2' :
∀ y ∈ Metric.ball t₀ a,
HasDerivAt f
((↑(extChartAt I.tangent { proj := x₀, snd := v x₀ }) ∘
(fun x => { proj := x, snd := v x }) ∘ ↑(extChartAt I x₀).symm)
(f y)).2
y
hcont : ∀ A ∈ 𝓝 (↑(extChartAt I x₀) x₀), f ⁻¹' A ∈ 𝓝 t₀
hnhds : ∀ᶠ (x' : ℝ) in 𝓝 t₀, f ⁻¹' interior (extChartAt I x₀).target ∈ 𝓝 x'
s : Set ℝ
hs : s ∈ 𝓝 t₀
haux :
∀ y ∈ s,
HasDerivAt f
((↑(extChartAt I.tangent { proj := x₀, snd := v x₀ }) ∘
(fun x => { proj := x, snd := v x }) ∘ ↑(extChartAt I x₀).symm)
(f y)).2
y ∧
f ⁻¹' interior (extChartAt I x₀).target ∈ 𝓝 y
t : ℝ
ht : t ∈ s
xₜ : M := ↑(extChartAt I x₀).symm (f t)
h : HasDerivAt f ((tangentCoordChange I xₜ x₀ xₜ) (v xₜ)) t
hf3 : f t ∈ interior (extChartAt I x₀).target
hf3' : f t ∈ (extChartAt I x₀).target
hft1 : ↑(extChartAt I x₀).symm (f t) ∈ (extChartAt I x₀).source
hft2 : xₜ ∈ (extChartAt I xₜ).source
⊢ HasMFDerivAt (modelWithCornersSelf ℝ ℝ) I (↑(extChartAt I x₀).symm ∘ f) t
(ContinuousLinearMap.smulRight 1 (v ((↑(extChartAt I x₀).symm ∘ f) t)))
|
b2c5f907bce00300
|
Rack.self_act_eq_iff_eq
|
Mathlib/Algebra/Quandle.lean
|
theorem self_act_eq_iff_eq {x y : R} : x ◃ x = y ◃ y ↔ x = y
|
case mp
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ x = y ◃ y → x = y
|
intro h
|
case mp
R : Type u_1
inst✝ : Rack R
x y : R
h : x ◃ x = y ◃ y
⊢ x = y
|
985d64cb6e461efd
|
aux₀
|
Mathlib/MeasureTheory/Order/UpperLower.lean
|
/-- If we can fit a small ball inside a set `s` intersected with any neighborhood of `x`, then the
density of `s` near `x` is not `0`.
Along with `aux₁`, this proves that `x` is a Lebesgue point of `s`. This will be used to prove that
the frontier of an order-connected set is null. -/
private lemma aux₀
(h : ∀ δ, 0 < δ →
∃ y, closedBall y (δ / 4) ⊆ closedBall x δ ∧ closedBall y (δ / 4) ⊆ interior s) :
¬Tendsto (fun r ↦ volume (closure s ∩ closedBall x r) / volume (closedBall x r)) (𝓝[>] 0)
(𝓝 0)
|
ι : Type u_1
inst✝ : Fintype ι
s : Set (ι → ℝ)
x : ι → ℝ
h : ∀ (δ : ℝ), 0 < δ → ∃ y, closedBall y (δ / 4) ⊆ closedBall x δ ∧ closedBall y (δ / 4) ⊆ interior s
⊢ ¬Tendsto (fun r => volume (closure s ∩ closedBall x r) / volume (closedBall x r)) (𝓝[>] 0) (𝓝 0)
|
choose f hf₀ hf₁ using h
|
ι : Type u_1
inst✝ : Fintype ι
s : Set (ι → ℝ)
x : ι → ℝ
f : (δ : ℝ) → 0 < δ → ι → ℝ
hf₀ : ∀ (δ : ℝ) (a : 0 < δ), closedBall (f δ a) (δ / 4) ⊆ closedBall x δ
hf₁ : ∀ (δ : ℝ) (a : 0 < δ), closedBall (f δ a) (δ / 4) ⊆ interior s
⊢ ¬Tendsto (fun r => volume (closure s ∩ closedBall x r) / volume (closedBall x r)) (𝓝[>] 0) (𝓝 0)
|
0d32daafddddd57d
|
Nat.factorization_choose_le_one
|
Mathlib/Data/Nat/Choose/Factorization.lean
|
theorem factorization_choose_le_one (p_large : n < p ^ 2) : (choose n k).factorization p ≤ 1
|
case inr
p n k : ℕ
p_large : n < p ^ 2
hn0 : n ≠ 0
⊢ log p n ≤ 1
|
exact Nat.lt_succ_iff.1 (log_lt_of_lt_pow hn0 p_large)
|
no goals
|
cceb2011e8e71a2f
|
MeasurableSpace.generateMeasurableRec_of_omega1_le
|
Mathlib/MeasureTheory/MeasurableSpace/Card.lean
|
theorem generateMeasurableRec_of_omega1_le (s : Set (Set α)) {i : Ordinal.{v}} (hi : ω₁ ≤ i) :
generateMeasurableRec s i = generateMeasurableRec s (ω₁ : Ordinal.{v})
|
α : Type u
s : Set (Set α)
i : Ordinal.{v}
hi : ω_ 1 ≤ i
⊢ generateMeasurableRec s i = generateMeasurableRec s (ω_ 1)
|
apply (generateMeasurableRec_mono s hi).antisymm'
|
α : Type u
s : Set (Set α)
i : Ordinal.{v}
hi : ω_ 1 ≤ i
⊢ generateMeasurableRec s i ≤ generateMeasurableRec s (ω_ 1)
|
5d8fe939fc21f9d6
|
IsDiscreteValuationRing.HasUnitMulPowIrreducibleFactorization.unique_irreducible
|
Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
|
theorem unique_irreducible (hR : HasUnitMulPowIrreducibleFactorization R)
⦃p q : R⦄ (hp : Irreducible p) (hq : Irreducible q) :
Associated p q
|
R : Type u_1
inst✝ : CommRing R
hR : HasUnitMulPowIrreducibleFactorization R
p q : R
hp : Irreducible p
hq : Irreducible q
⊢ Associated p q
|
rcases hR with ⟨ϖ, hϖ, hR⟩
|
case intro.intro
R : Type u_1
inst✝ : CommRing R
p q : R
hp : Irreducible p
hq : Irreducible q
ϖ : R
hϖ : Irreducible ϖ
hR : ∀ {x : R}, x ≠ 0 → ∃ n, Associated (ϖ ^ n) x
⊢ Associated p q
|
a4e838b13bdf1d0b
|
Real.iUnion_Iic_rat
|
Mathlib/Data/Real/Archimedean.lean
|
theorem iUnion_Iic_rat : ⋃ r : ℚ, Iic (r : ℝ) = univ
|
⊢ ⋃ r, Iic ↑r = univ
|
exact iUnion_Iic_of_not_bddAbove_range not_bddAbove_coe
|
no goals
|
e997ec3de0d7f0bf
|
Polynomial.separable_X_pow_sub_C_of_irreducible
|
Mathlib/FieldTheory/KummerExtension.lean
|
theorem Polynomial.separable_X_pow_sub_C_of_irreducible : (X ^ n - C a).Separable
|
case neg
K : Type u
inst✝ : Field K
n : ℕ
hζ✝ : (primitiveRoots n K).Nonempty
a : K
H : Irreducible (X ^ n - C a)
this✝ : Fact (Irreducible (X ^ n - C a)) := { out := H }
this : Algebra K K[n√a] := inferInstance
hn : 0 < n
hn' : ¬n = 1
ζ : K
hζ : IsPrimitiveRoot ζ n
⊢ ∀ x ∈ Finset.range n,
∀ y ∈ Finset.range n,
(algebraMap K K[n√a]) ζ ^ x * root (X ^ n - C a) = (algebraMap K K[n√a]) ζ ^ y * root (X ^ n - C a) → x = y
|
have : MonoidHomClass (K →+* K[n√a]) K K[n√a] := inferInstance
|
case neg
K : Type u
inst✝ : Field K
n : ℕ
hζ✝ : (primitiveRoots n K).Nonempty
a : K
H : Irreducible (X ^ n - C a)
this✝¹ : Fact (Irreducible (X ^ n - C a)) := { out := H }
this✝ : Algebra K K[n√a] := inferInstance
hn : 0 < n
hn' : ¬n = 1
ζ : K
hζ : IsPrimitiveRoot ζ n
this : MonoidHomClass (K →+* K[n√a]) K K[n√a]
⊢ ∀ x ∈ Finset.range n,
∀ y ∈ Finset.range n,
(algebraMap K K[n√a]) ζ ^ x * root (X ^ n - C a) = (algebraMap K K[n√a]) ζ ^ y * root (X ^ n - C a) → x = y
|
162933979857b32b
|
AlgebraicGeometry.exists_basicOpen_le_appLE_of_appLE_of_isAffine
|
Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean
|
/-- If `P` holds for `f` over affine opens `U₂` of `Y` and `V₂` of `X` and `U₁` (resp. `V₁`) are
open affine neighborhoods of `x` (resp. `f.base x`), then `P` also holds for `f`
over some basic open of `U₁` (resp. `V₁`). -/
lemma exists_basicOpen_le_appLE_of_appLE_of_isAffine
(hPa : StableUnderCompositionWithLocalizationAwayTarget P) (hPl : LocalizationAwayPreserves P)
(x : X) (U₁ : Y.affineOpens) (U₂ : Y.affineOpens) (V₁ : X.affineOpens) (V₂ : X.affineOpens)
(hx₁ : x ∈ V₁.1) (hx₂ : x ∈ V₂.1) (e₂ : V₂.1 ≤ f ⁻¹ᵁ U₂.1) (h₂ : P (f.appLE U₂ V₂ e₂).hom)
(hfx₁ : f.base x ∈ U₁.1) :
∃ (r : Γ(Y, U₁)) (s : Γ(X, V₁)) (_ : x ∈ X.basicOpen s)
(e : X.basicOpen s ≤ f ⁻¹ᵁ Y.basicOpen r),
P (f.appLE (Y.basicOpen r) (X.basicOpen s) e).hom
|
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
X Y : Scheme
f : X ⟶ Y
hPa : StableUnderCompositionWithLocalizationAwayTarget fun {R S} [CommRing R] [CommRing S] => P
hPl : LocalizationAwayPreserves fun {R S} [CommRing R] [CommRing S] => P
x : ↑↑X.toPresheafedSpace
U₁ U₂ : ↑Y.affineOpens
V₁ V₂ : ↑X.affineOpens
hx₁ : x ∈ ↑V₁
hx₂ : x ∈ ↑V₂
e₂ : ↑V₂ ≤ f ⁻¹ᵁ ↑U₂
h₂ : P (CommRingCat.Hom.hom (Scheme.Hom.appLE f (↑U₂) (↑V₂) e₂))
hfx₁ : (ConcreteCategory.hom f.base) x ∈ ↑U₁
r : ↑Γ(Y, ↑U₁)
r' : ↑Γ(Y, ↑U₂)
hBrr' : Y.basicOpen r = Y.basicOpen r'
hBfx : (ConcreteCategory.hom f.base) x ∈ Y.basicOpen r
ha : IsAffineOpen (X.basicOpen ((ConcreteCategory.hom (Scheme.Hom.appLE f (↑U₂) (↑V₂) e₂)) r'))
hxa : x ∈ X.basicOpen ((ConcreteCategory.hom (Scheme.Hom.appLE f (↑U₂) (↑V₂) e₂)) r')
s : ↑Γ(X, ↑V₁)
s' : ↑Γ(X, X.basicOpen ((ConcreteCategory.hom (Scheme.Hom.appLE f (↑U₂) (↑V₂) e₂)) r'))
hBss' : X.basicOpen s = X.basicOpen s'
hBx : x ∈ X.basicOpen s
this✝¹ :
IsLocalization.Away ((ConcreteCategory.hom (Scheme.Hom.appLE f (↑U₂) (↑V₂) e₂)) r')
↑Γ(X, X.basicOpen ((ConcreteCategory.hom (Scheme.Hom.appLE f (↑U₂) (↑V₂) e₂)) r'))
this✝ : IsLocalization.Away r' ↑Γ(Y, Y.basicOpen r')
this : IsLocalization.Away s' ↑Γ(X, X.basicOpen s')
ers : X.basicOpen s ≤ f ⁻¹ᵁ Y.basicOpen r
⊢ Scheme.Hom.app f (Y.basicOpen r') ≫ X.presheaf.map (homOfLE ⋯).op =
Scheme.Hom.app f (Y.basicOpen r') ≫
X.presheaf.map (homOfLE ⋯).op ≫
CommRingCat.ofHom
(algebraMap
↑(X.presheaf.toPrefunctor.1
(Opposite.op
(X.basicOpen ((ConcreteCategory.hom (Scheme.Hom.app f ↑U₂ ≫ X.presheaf.map (homOfLE e₂).op)) r'))))
↑(X.presheaf.toPrefunctor.1 (Opposite.op (X.basicOpen s'))))
|
congr
|
case e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
X Y : Scheme
f : X ⟶ Y
hPa : StableUnderCompositionWithLocalizationAwayTarget fun {R S} [CommRing R] [CommRing S] => P
hPl : LocalizationAwayPreserves fun {R S} [CommRing R] [CommRing S] => P
x : ↑↑X.toPresheafedSpace
U₁ U₂ : ↑Y.affineOpens
V₁ V₂ : ↑X.affineOpens
hx₁ : x ∈ ↑V₁
hx₂ : x ∈ ↑V₂
e₂ : ↑V₂ ≤ f ⁻¹ᵁ ↑U₂
h₂ : P (CommRingCat.Hom.hom (Scheme.Hom.appLE f (↑U₂) (↑V₂) e₂))
hfx₁ : (ConcreteCategory.hom f.base) x ∈ ↑U₁
r : ↑Γ(Y, ↑U₁)
r' : ↑Γ(Y, ↑U₂)
hBrr' : Y.basicOpen r = Y.basicOpen r'
hBfx : (ConcreteCategory.hom f.base) x ∈ Y.basicOpen r
ha : IsAffineOpen (X.basicOpen ((ConcreteCategory.hom (Scheme.Hom.appLE f (↑U₂) (↑V₂) e₂)) r'))
hxa : x ∈ X.basicOpen ((ConcreteCategory.hom (Scheme.Hom.appLE f (↑U₂) (↑V₂) e₂)) r')
s : ↑Γ(X, ↑V₁)
s' : ↑Γ(X, X.basicOpen ((ConcreteCategory.hom (Scheme.Hom.appLE f (↑U₂) (↑V₂) e₂)) r'))
hBss' : X.basicOpen s = X.basicOpen s'
hBx : x ∈ X.basicOpen s
this✝¹ :
IsLocalization.Away ((ConcreteCategory.hom (Scheme.Hom.appLE f (↑U₂) (↑V₂) e₂)) r')
↑Γ(X, X.basicOpen ((ConcreteCategory.hom (Scheme.Hom.appLE f (↑U₂) (↑V₂) e₂)) r'))
this✝ : IsLocalization.Away r' ↑Γ(Y, Y.basicOpen r')
this : IsLocalization.Away s' ↑Γ(X, X.basicOpen s')
ers : X.basicOpen s ≤ f ⁻¹ᵁ Y.basicOpen r
⊢ X.presheaf.map (homOfLE ⋯).op =
X.presheaf.map (homOfLE ⋯).op ≫
CommRingCat.ofHom
(algebraMap
↑(X.presheaf.toPrefunctor.1
(Opposite.op
(X.basicOpen ((ConcreteCategory.hom (Scheme.Hom.app f ↑U₂ ≫ X.presheaf.map (homOfLE e₂).op)) r'))))
↑(X.presheaf.toPrefunctor.1 (Opposite.op (X.basicOpen s'))))
|
cdf0cd1399279970
|
CategoryTheory.composePath_comp
|
Mathlib/CategoryTheory/PathCategory/Basic.lean
|
theorem composePath_comp {X Y Z : C} (f : Path X Y) (g : Path Y Z) :
composePath (f.comp g) = composePath f ≫ composePath g
|
case cons
C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y Z : C
f : Path X Y
Y' Z' : C
g : Path Y Y'
e : Y' ⟶ Z'
ih : composePath (f.comp g) = composePath f ≫ composePath g
⊢ composePath (f.comp (g.cons e)) = composePath f ≫ composePath (g.cons e)
|
simp [ih]
|
no goals
|
755342b6a7c06734
|
IsCompact.exists_thickening_image_subset
|
Mathlib/Topology/MetricSpace/Thickening.lean
|
theorem IsCompact.exists_thickening_image_subset
[PseudoEMetricSpace α] {β : Type*} [PseudoEMetricSpace β]
{f : α → β} {K : Set α} {U : Set β} (hK : IsCompact K) (ho : IsOpen U)
(hf : ∀ x ∈ K, ContinuousAt f x) (hKU : MapsTo f K U) :
∃ ε > 0, ∃ V ∈ 𝓝ˢ K, thickening ε (f '' V) ⊆ U
|
case hnhds.intro.intro
α : Type u
inst✝¹ : PseudoEMetricSpace α
β : Type u_2
inst✝ : PseudoEMetricSpace β
f : α → β
K : Set α
U : Set β
hK : IsCompact K
ho : IsOpen U
hf : ∀ x ∈ K, ContinuousAt f x
hKU : MapsTo f K U
x : α
hx : x ∈ K
this : {f x} ⊆ U
δ : ℝ
hδ : 0 < δ
hthick : thickening δ {f x} ⊆ U
V : Set α := f ⁻¹' thickening (δ / 2) {f x}
⊢ ∃ t ∈ 𝓝[K] x, ∃ ε > 0, ∃ V ∈ 𝓝ˢ t, thickening ε (f '' V) ⊆ U
|
have : V ∈ 𝓝 x := by
apply hf x hx
apply isOpen_thickening.mem_nhds
exact (self_subset_thickening (by positivity) _) rfl
|
case hnhds.intro.intro
α : Type u
inst✝¹ : PseudoEMetricSpace α
β : Type u_2
inst✝ : PseudoEMetricSpace β
f : α → β
K : Set α
U : Set β
hK : IsCompact K
ho : IsOpen U
hf : ∀ x ∈ K, ContinuousAt f x
hKU : MapsTo f K U
x : α
hx : x ∈ K
this✝ : {f x} ⊆ U
δ : ℝ
hδ : 0 < δ
hthick : thickening δ {f x} ⊆ U
V : Set α := f ⁻¹' thickening (δ / 2) {f x}
this : V ∈ 𝓝 x
⊢ ∃ t ∈ 𝓝[K] x, ∃ ε > 0, ∃ V ∈ 𝓝ˢ t, thickening ε (f '' V) ⊆ U
|
d761bc6cba03edce
|
Profinite.NobelingProof.GoodProducts.spanFin
|
Mathlib/Topology/Category/Profinite/Nobeling.lean
|
theorem GoodProducts.spanFin [WellFoundedLT I] :
⊤ ≤ Submodule.span ℤ (Set.range (eval (π C (· ∈ s))))
|
I : Type u
C : Set (I → Bool)
inst✝¹ : LinearOrder I
s : Finset I
inst✝ : WellFoundedLT I
x : ↑(π C fun x => x ∈ s)
l : List I := Finset.sort (fun x1 x2 => x1 ≥ x2) s
a : I
as : List I
ha : List.Chain' (fun x1 x2 => x1 > x2) (a :: as)
c : Products I →₀ ℤ
hc : ↑c.support ⊆ {m | ↑m ≤ as}
hmap :
∀ (g : Products I → ℤ → LocallyConstant ↑(π C fun x => x ∈ s) ℤ),
e (π C fun x => x ∈ s) a * c.sum g = c.sum fun a_1 b => e (π C fun x => x ∈ s) a * g a_1 b
h✝ : ¬↑x a = true
m : Products I
hm : c m ≠ 0
⊢ m ∈ ↑c.support
|
simpa only [Finset.mem_coe, Finsupp.mem_support_iff] using hm
|
no goals
|
84857795ad4a98fd
|
Finset.Colex.trans_aux
|
Mathlib/Combinatorics/Colex.lean
|
private lemma trans_aux (hst : toColex s ≤ toColex t) (htu : toColex t ≤ toColex u)
(has : a ∈ s) (hat : a ∉ t) : ∃ b, b ∈ u ∧ b ∉ s ∧ a ≤ b
|
α : Type u_1
inst✝ : PartialOrder α
s t u : Finset α
a : α
hst : { ofColex := s } ≤ { ofColex := t }
htu : { ofColex := t } ≤ { ofColex := u }
has : a ∈ s
hat : a ∉ t
s' : Finset α := filter (fun b => b ∉ t ∧ a ≤ b) s
⊢ a ∈ s'
|
simp [s', has, hat]
|
no goals
|
d44eef7b38eb8d38
|
IsAlgebraic.exists_integral_multiple
|
Mathlib/RingTheory/Algebraic/Integral.lean
|
theorem exists_integral_multiple (hz : IsAlgebraic R z) : ∃ y ≠ (0 : R), IsIntegral R (y • z)
|
case pos
R : Type u_1
A : Type u_3
inst✝² : CommRing R
inst✝¹ : Ring A
inst✝ : Algebra R A
z : A
hz : IsAlgebraic R z
inj : Function.Injective ⇑(algebraMap R A)
p : R[X]
p_ne_zero : p ≠ 0
px : (aeval z) p = 0
a : R := p.leadingCoeff
a_ne_zero : a ≠ 0
⊢ ∃ y, y ≠ 0 ∧ IsIntegral R (y • z)
|
have x_integral : IsIntegral R (algebraMap R A a * z) :=
⟨p.integralNormalization, monic_integralNormalization p_ne_zero,
integralNormalization_aeval_eq_zero px fun _ ↦ (map_eq_zero_iff _ inj).mp⟩
|
case pos
R : Type u_1
A : Type u_3
inst✝² : CommRing R
inst✝¹ : Ring A
inst✝ : Algebra R A
z : A
hz : IsAlgebraic R z
inj : Function.Injective ⇑(algebraMap R A)
p : R[X]
p_ne_zero : p ≠ 0
px : (aeval z) p = 0
a : R := p.leadingCoeff
a_ne_zero : a ≠ 0
x_integral : IsIntegral R ((algebraMap R A) a * z)
⊢ ∃ y, y ≠ 0 ∧ IsIntegral R (y • z)
|
bbcb89efa15f355a
|
Module.End_isUnit_inv_apply_apply_of_isUnit
|
Mathlib/Algebra/Module/LinearMap/End.lean
|
theorem _root_.Module.End_isUnit_inv_apply_apply_of_isUnit
{f : Module.End R M} (h : IsUnit f) (x : M) :
h.unit.inv (f x) = x :=
(by simp : (h.unit.inv * f) x = x)
|
R : Type u_1
M : Type u_4
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : Module.End R M
h : IsUnit f
x : M
⊢ (h.unit.inv * f) x = x
|
simp
|
no goals
|
383b162ce542c51f
|
BitVec.lt_of_getMsbD
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
|
theorem lt_of_getMsbD {x : BitVec w} {i : Nat} : getMsbD x i = true → i < w
|
w : Nat
x : BitVec w
i : Nat
h : ¬i < w
⊢ x.getMsbD i = true → i < w
|
simp [Nat.ge_of_not_lt h]
|
no goals
|
ca368506eb0e50ad
|
List.mergeSort_nil
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Sort/Lemmas.lean
|
theorem mergeSort_nil : [].mergeSort r = []
|
α✝ : Type u_1
r : α✝ → α✝ → Bool
⊢ [].mergeSort r = []
|
rw [List.mergeSort]
|
no goals
|
5db18dbfedff5412
|
Cardinal.mk_le_of_module
|
Mathlib/Algebra/Module/Card.lean
|
theorem mk_le_of_module (R : Type u) (E : Type v)
[AddCommGroup E] [Ring R] [Module R E] [Nontrivial E] [NoZeroSMulDivisors R E] :
Cardinal.lift.{v} (#R) ≤ Cardinal.lift.{u} (#E)
|
case intro
R : Type u
E : Type v
inst✝⁴ : AddCommGroup E
inst✝³ : Ring R
inst✝² : Module R E
inst✝¹ : Nontrivial E
inst✝ : NoZeroSMulDivisors R E
x : E
hx : x ≠ 0
this : Injective fun k => k • x
⊢ lift.{v, u} #R ≤ lift.{u, v} #E
|
exact lift_mk_le_lift_mk_of_injective this
|
no goals
|
75f23a3727a1d651
|
NNReal.tendsto_of_antitone
|
Mathlib/Topology/Instances/NNReal/Lemmas.lean
|
theorem tendsto_of_antitone {f : ℕ → ℝ≥0} (h_ant : Antitone f) :
∃ r : ℝ≥0, Tendsto f atTop (𝓝 r)
|
case intro
f : ℕ → ℝ≥0
h_ant : Antitone f
r : ℝ
n : ℕ
hn : (fun n => ↑(f n)) n = r
⊢ 0 ≤ r
|
simp_rw [← hn]
|
case intro
f : ℕ → ℝ≥0
h_ant : Antitone f
r : ℝ
n : ℕ
hn : (fun n => ↑(f n)) n = r
⊢ 0 ≤ ↑(f n)
|
dd15c78146648c25
|
Turing.ListBlank.ext
|
Mathlib/Computability/Tape.lean
|
theorem ListBlank.ext {Γ} [i : Inhabited Γ] {L₁ L₂ : ListBlank Γ} :
(∀ i, L₁.nth i = L₂.nth i) → L₁ = L₂
|
case inr.inr.H
Γ : Type u_1
i : Inhabited Γ
L₁ L₂ : ListBlank Γ
l₁ l₂ : List Γ
H : ∀ (i_1 : ℕ), (mk l₁).nth i_1 = (mk l₂).nth i_1
this :
∀ {Γ : Type u_1} [i : Inhabited Γ] {L₁ L₂ : ListBlank Γ} (l₁ l₂ : List Γ),
(∀ (i_1 : ℕ), (mk l₁).nth i_1 = (mk l₂).nth i_1) → l₁.length ≤ l₂.length → mk l₁ = mk l₂
h : ¬l₁.length ≤ l₂.length
h✝ : l₂.length ≤ l₁.length
⊢ ∀ (i_1 : ℕ), (mk l₂).nth i_1 = (mk l₁).nth i_1
|
intro
|
case inr.inr.H
Γ : Type u_1
i : Inhabited Γ
L₁ L₂ : ListBlank Γ
l₁ l₂ : List Γ
H : ∀ (i_1 : ℕ), (mk l₁).nth i_1 = (mk l₂).nth i_1
this :
∀ {Γ : Type u_1} [i : Inhabited Γ] {L₁ L₂ : ListBlank Γ} (l₁ l₂ : List Γ),
(∀ (i_1 : ℕ), (mk l₁).nth i_1 = (mk l₂).nth i_1) → l₁.length ≤ l₂.length → mk l₁ = mk l₂
h : ¬l₁.length ≤ l₂.length
h✝ : l₂.length ≤ l₁.length
i✝ : ℕ
⊢ (mk l₂).nth i✝ = (mk l₁).nth i✝
|
fd463af825144e5d
|
hyperoperation_ge_two_eq_self
|
Mathlib/Data/Nat/Hyperoperation.lean
|
theorem hyperoperation_ge_two_eq_self (n m : ℕ) : hyperoperation (n + 2) m 1 = m
|
n m : ℕ
⊢ hyperoperation (n + 2) m 1 = m
|
induction' n with nn nih
|
case zero
m : ℕ
⊢ hyperoperation (0 + 2) m 1 = m
case succ
m nn : ℕ
nih : hyperoperation (nn + 2) m 1 = m
⊢ hyperoperation (nn + 1 + 2) m 1 = m
|
ea562c89101789f2
|
EisensteinSeries.auxbound1
|
Mathlib/NumberTheory/ModularForms/EisensteinSeries/UniformConvergence.lean
|
lemma auxbound1 {c : ℝ} (d : ℝ) (hc : 1 ≤ c ^ 2) : r z ≤ ‖c * (z : ℂ) + d‖
|
z : ℍ
c d : ℝ
hc : 1 ≤ c ^ 2
⊢ r z ≤ ‖↑c * ↑z + ↑d‖
|
rcases z with ⟨z, hz⟩
|
case mk
c d : ℝ
hc : 1 ≤ c ^ 2
z : ℂ
hz : 0 < z.im
⊢ r ⟨z, hz⟩ ≤ ‖↑c * ↑⟨z, hz⟩ + ↑d‖
|
e8fac847c19bb038
|
Std.DHashMap.Raw.size_alter_eq_sub_one
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/RawLemmas.lean
|
theorem size_alter_eq_sub_one [LawfulBEq α] {k : α} {f : Option (β k) → Option (β k)}
(h : m.WF) (h₁ : k ∈ m) (h₂ : (f (m.get? k)).isNone) :
(m.alter k f).size = m.size - 1
|
α : Type u
β : α → Type v
inst✝² : BEq α
inst✝¹ : Hashable α
m : Raw α β
inst✝ : LawfulBEq α
k : α
f : Option (β k) → Option (β k)
h : m.WF
⊢ k ∈ m → (f (m.get? k)).isNone = true → (m.alter k f).size = m.size - 1
|
simp only [mem_iff_contains]
|
α : Type u
β : α → Type v
inst✝² : BEq α
inst✝¹ : Hashable α
m : Raw α β
inst✝ : LawfulBEq α
k : α
f : Option (β k) → Option (β k)
h : m.WF
⊢ m.contains k = true → (f (m.get? k)).isNone = true → (m.alter k f).size = m.size - 1
|
d90b6a80187b2ce0
|
List.idxOf_eq_length_iff
|
Mathlib/Data/List/Basic.lean
|
theorem idxOf_eq_length_iff {a : α} {l : List α} : idxOf a l = length l ↔ a ∉ l
|
case neg
α : Type u
inst✝ : DecidableEq α
a b : α
l : List α
ih : idxOf a l = l.length ↔ ¬a ∈ l
h : ¬b = a
⊢ idxOf a l + 1 = l.length + 1 ↔ ¬a ∈ l
|
rw [← ih]
|
case neg
α : Type u
inst✝ : DecidableEq α
a b : α
l : List α
ih : idxOf a l = l.length ↔ ¬a ∈ l
h : ¬b = a
⊢ idxOf a l + 1 = l.length + 1 ↔ idxOf a l = l.length
|
9447f2f883c10679
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.