Context stringlengths 57 6.04k | file_name stringlengths 21 79 | start int64 14 1.49k | end int64 18 1.5k | theorem stringlengths 25 1.55k | proof stringlengths 5 7.36k | goals listlengths 0 224 | goals_before listlengths 0 220 |
|---|---|---|---|---|---|---|---|
import Mathlib.Order.Interval.Set.Monotone
import Mathlib.Probability.Process.HittingTime
import Mathlib.Probability.Martingale.Basic
import Mathlib.Tactic.AdaptationNote
#align_import probability.martingale.upcrossing from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba144755cd1"
open Topological... | Mathlib/Probability/Martingale/Upcrossing.lean | 173 | 176 | theorem upperCrossingTime_succ_eq (ω : Ω) : upperCrossingTime a b f N (n + 1) ω =
hitting f (Set.Ici b) (lowerCrossingTime a b f N n ω) N ω := by |
simp only [upperCrossingTime_succ]
rfl
| [
" upperCrossingTime a b f N (n + 1) ω =\n hitting f (Set.Ici b) (lowerCrossingTimeAux a f (upperCrossingTime a b f N n ω) N ω) N ω",
" upperCrossingTime a b f N (n + 1) ω = hitting f (Set.Ici b) (lowerCrossingTime a b f N n ω) N ω",
" hitting f (Set.Ici b) (lowerCrossingTimeAux a f (upperCrossingTime a b f N... | [
" upperCrossingTime a b f N (n + 1) ω =\n hitting f (Set.Ici b) (lowerCrossingTimeAux a f (upperCrossingTime a b f N n ω) N ω) N ω"
] |
import Mathlib.Algebra.GCDMonoid.Finset
import Mathlib.Algebra.Polynomial.CancelLeads
import Mathlib.Algebra.Polynomial.EraseLead
import Mathlib.Algebra.Polynomial.FieldDivision
#align_import ring_theory.polynomial.content from "leanprover-community/mathlib"@"7a030ab8eb5d99f05a891dccc49c5b5b90c947d3"
namespace Po... | Mathlib/RingTheory/Polynomial/Content.lean | 154 | 155 | theorem content_monomial {r : R} {k : ℕ} : content (monomial k r) = normalize r := by |
rw [← C_mul_X_pow_eq_monomial, content_C_mul, content_X_pow, mul_one]
| [
" p.content ∣ p.coeff n",
" p.content ∣ 0",
" (C r).content = normalize r",
" (C r).support.gcd (C r).coeff = normalize r",
" content 0 = 0",
" content 1 = 1",
" (X * p).content = p.content",
" (Multiset.map (X * p).coeff (X * p).support.val).gcd = (Multiset.map p.coeff p.support.val).gcd",
" Multis... | [
" p.content ∣ p.coeff n",
" p.content ∣ 0",
" (C r).content = normalize r",
" (C r).support.gcd (C r).coeff = normalize r",
" content 0 = 0",
" content 1 = 1",
" (X * p).content = p.content",
" (Multiset.map (X * p).coeff (X * p).support.val).gcd = (Multiset.map p.coeff p.support.val).gcd",
" Multis... |
import Mathlib.CategoryTheory.Subobject.Lattice
#align_import category_theory.subobject.limits from "leanprover-community/mathlib"@"956af7c76589f444f2e1313911bad16366ea476d"
universe v u
noncomputable section
open CategoryTheory CategoryTheory.Category CategoryTheory.Limits CategoryTheory.Subobject Opposite
var... | Mathlib/CategoryTheory/Subobject/Limits.lean | 134 | 137 | theorem factorThruKernelSubobject_comp_arrow {W : C} (h : W ⟶ X) (w : h ≫ f = 0) :
factorThruKernelSubobject f h w ≫ (kernelSubobject f).arrow = h := by |
dsimp [factorThruKernelSubobject]
simp
| [
" (kernelSubobjectIso f).hom ≫ kernel.ι f = (kernelSubobject f).arrow",
" (kernelSubobjectIso f).inv ≫ (kernelSubobject f).arrow = kernel.ι f",
" (kernelSubobject f).arrow ≫ f = 0",
" ((kernelSubobjectIso f).hom ≫ kernel.ι f) ≫ f = 0",
" kernel.lift f h w ≫ (MonoOver.mk' (kernel.ι f)).arrow = h",
" h ≫ f ... | [
" (kernelSubobjectIso f).hom ≫ kernel.ι f = (kernelSubobject f).arrow",
" (kernelSubobjectIso f).inv ≫ (kernelSubobject f).arrow = kernel.ι f",
" (kernelSubobject f).arrow ≫ f = 0",
" ((kernelSubobjectIso f).hom ≫ kernel.ι f) ≫ f = 0",
" kernel.lift f h w ≫ (MonoOver.mk' (kernel.ι f)).arrow = h",
" h ≫ f ... |
import Mathlib.Algebra.Algebra.Spectrum
import Mathlib.FieldTheory.IsAlgClosed.Basic
#align_import field_theory.is_alg_closed.spectrum from "leanprover-community/mathlib"@"58a272265b5e05f258161260dd2c5d247213cbd3"
namespace spectrum
open Set Polynomial
open scoped Pointwise Polynomial
universe u v
section Scal... | Mathlib/FieldTheory/IsAlgClosed/Spectrum.lean | 55 | 63 | theorem exists_mem_of_not_isUnit_aeval_prod [IsDomain R] {p : R[X]} {a : A}
(h : ¬IsUnit (aeval a (Multiset.map (fun x : R => X - C x) p.roots).prod)) :
∃ k : R, k ∈ σ a ∧ eval k p = 0 := by |
rw [← Multiset.prod_toList, AlgHom.map_list_prod] at h
replace h := mt List.prod_isUnit h
simp only [not_forall, exists_prop, aeval_C, Multiset.mem_toList, List.mem_map, aeval_X,
exists_exists_and_eq_and, Multiset.mem_map, AlgHom.map_sub] at h
rcases h with ⟨r, r_mem, r_nu⟩
exact ⟨r, by rwa [mem_iff, ← I... | [
" ∃ k ∈ σ a, eval k p = 0",
" r ∈ σ a"
] | [] |
import Mathlib.Analysis.NormedSpace.IndicatorFunction
import Mathlib.MeasureTheory.Function.EssSup
import Mathlib.MeasureTheory.Function.AEEqFun
import Mathlib.MeasureTheory.Function.SpecialFunctions.Basic
#align_import measure_theory.function.lp_seminorm from "leanprover-community/mathlib"@"c4015acc0a223449d44061e27... | Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean | 91 | 93 | theorem snorm_eq_lintegral_rpow_nnnorm (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞) {f : α → F} :
snorm f p μ = (∫⁻ x, (‖f x‖₊ : ℝ≥0∞) ^ p.toReal ∂μ) ^ (1 / p.toReal) := by |
rw [snorm_eq_snorm' hp_ne_zero hp_ne_top, snorm']
| [
" snorm f p μ = snorm' f p.toReal μ",
" snorm f p μ = (∫⁻ (x : α), ↑‖f x‖₊ ^ p.toReal ∂μ) ^ (1 / p.toReal)"
] | [
" snorm f p μ = snorm' f p.toReal μ"
] |
import Batteries.Tactic.Init
import Batteries.Tactic.Alias
import Batteries.Tactic.Lint.Misc
instance {f : α → β} [DecidablePred p] : DecidablePred (p ∘ f) :=
inferInstanceAs <| DecidablePred fun x => p (f x)
@[deprecated] alias proofIrrel := proof_irrel
theorem Function.id_def : @id α = fun x => x := rfl
al... | .lake/packages/batteries/Batteries/Logic.lean | 88 | 91 | theorem eqRec_eq_cast {α : Sort _} {a : α} {motive : (a' : α) → a = a' → Sort _}
(x : motive a (rfl : a = a)) {a' : α} (e : a = a') :
@Eq.rec α a motive x a' e = cast (e ▸ rfl) x := by |
subst e; rfl
| [
" h ▸ y = y",
" ⋯ ▸ y = y",
" f x y = f x' y'",
" f x y = f x y",
" x₁ = x₂ ↔ y₁ = y₂",
" x₁ = x₂ ↔ x₁ = y₂",
" x₁ = x₂ ↔ x₁ = x₂",
" x = z ↔ y = z",
" z = x ↔ z = y",
" cast e a = a'",
" cast e a = a",
" e ▸ x = cast ⋯ x",
" ⋯ ▸ x = cast ⋯ x"
] | [
" h ▸ y = y",
" ⋯ ▸ y = y",
" f x y = f x' y'",
" f x y = f x y",
" x₁ = x₂ ↔ y₁ = y₂",
" x₁ = x₂ ↔ x₁ = y₂",
" x₁ = x₂ ↔ x₁ = x₂",
" x = z ↔ y = z",
" z = x ↔ z = y",
" cast e a = a'",
" cast e a = a"
] |
import Mathlib.Algebra.Group.Basic
import Mathlib.Algebra.GroupWithZero.NeZero
import Mathlib.Logic.Unique
#align_import algebra.group_with_zero.basic from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"
assert_not_exists DenselyOrdered
open scoped Classical
open Function
variable {α M... | Mathlib/Algebra/GroupWithZero/Basic.lean | 110 | 111 | theorem eq_zero_of_zero_eq_one (h : (0 : M₀) = 1) (a : M₀) : a = 0 := by |
rw [← mul_one a, ← h, mul_zero]
| [
" a = 0"
] | [] |
import Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic
import Mathlib.CategoryTheory.Monoidal.Functorial
import Mathlib.CategoryTheory.Monoidal.Types.Basic
import Mathlib.LinearAlgebra.DirectSum.Finsupp
import Mathlib.CategoryTheory.Linear.LinearFunctor
#align_import algebra.category.Module.adjunctions from "leanpr... | Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean | 132 | 149 | theorem right_unitality (X : Type u) :
(ρ_ ((free R).obj X)).hom =
(𝟙 ((free R).obj X) ⊗ ε R) ≫ (μ R X (𝟙_ (Type u))).hom ≫ map (free R).obj (ρ_ X).hom := by |
-- Porting note (#11041): broken ext
apply TensorProduct.ext
apply Finsupp.lhom_ext'
intro x
apply LinearMap.ext_ring
apply LinearMap.ext_ring
apply Finsupp.ext
intro x'
-- Porting note (#10934): used to be dsimp [ε, μ]
let q : X →₀ R := ((ρ_ (of R (X →₀ R))).hom) (Finsupp.single x 1 ⊗ₜ[R] 1)
cha... | [
" ∀ (X : Type u),\n { obj := fun X => of R (X →₀ R), map := fun {X Y} f => Finsupp.lmapDomain R R f }.map (𝟙 X) =\n 𝟙 ({ obj := fun X => of R (X →₀ R), map := fun {X Y} f => Finsupp.lmapDomain R R f }.obj X)",
" { obj := fun X => of R (X →₀ R), map := fun {X Y} f => Finsupp.lmapDomain R R f }.map (𝟙 X✝... | [
" ∀ (X : Type u),\n { obj := fun X => of R (X →₀ R), map := fun {X Y} f => Finsupp.lmapDomain R R f }.map (𝟙 X) =\n 𝟙 ({ obj := fun X => of R (X →₀ R), map := fun {X Y} f => Finsupp.lmapDomain R R f }.obj X)",
" { obj := fun X => of R (X →₀ R), map := fun {X Y} f => Finsupp.lmapDomain R R f }.map (𝟙 X✝... |
import Mathlib.Algebra.MvPolynomial.Degrees
#align_import data.mv_polynomial.variables from "leanprover-community/mathlib"@"2f5b500a507264de86d666a5f87ddb976e2d8de4"
noncomputable section
open Set Function Finsupp AddMonoidAlgebra
universe u v w
variable {R : Type u} {S : Type v}
namespace MvPolynomial
varia... | Mathlib/Algebra/MvPolynomial/Variables.lean | 98 | 99 | theorem mem_vars (i : σ) : i ∈ p.vars ↔ ∃ d ∈ p.support, i ∈ d.support := by |
classical simp only [vars_def, Multiset.mem_toFinset, mem_degrees, mem_support_iff, exists_prop]
| [
" p.vars = p.degrees.toFinset",
" p.degrees.toFinset = p.degrees.toFinset",
" vars 0 = ∅",
" ((monomial s) r).vars = s.support",
" (C r).vars = ∅",
" (X n).vars = {n}",
" i ∈ p.vars ↔ ∃ d ∈ p.support, i ∈ d.support"
] | [
" p.vars = p.degrees.toFinset",
" p.degrees.toFinset = p.degrees.toFinset",
" vars 0 = ∅",
" ((monomial s) r).vars = s.support",
" (C r).vars = ∅",
" (X n).vars = {n}"
] |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.GeomSum
import Mathlib.LinearAlgebra.Matrix.Block
import Mathlib.LinearAlgebra.Matrix.Determinant.Basic
import Mathlib.LinearAlgebra.Matrix.Nondegenerate
#align_import linear_algebra.vandermonde from "leanprover-community/mathlib"@"70fd9563a21e7b963887c93... | Mathlib/LinearAlgebra/Vandermonde.lean | 72 | 74 | theorem vandermonde_transpose_mul_vandermonde {n : ℕ} (v : Fin n → R) (i j) :
((vandermonde v)ᵀ * vandermonde v) i j = ∑ k : Fin n, v k ^ (i + j : ℕ) := by |
simp only [vandermonde_apply, Matrix.mul_apply, Matrix.transpose_apply, pow_add]
| [
" vandermonde (Fin.cons v0 v) = Fin.cons (fun j => v0 ^ ↑j) fun i => Fin.cons 1 fun j => v i * vandermonde v i j",
" vandermonde (Fin.cons v0 v) i j =\n Fin.cons (fun j => v0 ^ ↑j) (fun i => Fin.cons 1 fun j => v i * vandermonde v i j) i j",
" vandermonde (Fin.cons v0 v) 0 j =\n Fin.cons (fun j => v0 ^ ↑j... | [
" vandermonde (Fin.cons v0 v) = Fin.cons (fun j => v0 ^ ↑j) fun i => Fin.cons 1 fun j => v i * vandermonde v i j",
" vandermonde (Fin.cons v0 v) i j =\n Fin.cons (fun j => v0 ^ ↑j) (fun i => Fin.cons 1 fun j => v i * vandermonde v i j) i j",
" vandermonde (Fin.cons v0 v) 0 j =\n Fin.cons (fun j => v0 ^ ↑j... |
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Algebra.Group.Submonoid.Basic
import Mathlib.Deprecated.Group
#align_import deprecated.submonoid from "leanprover-community/mathlib"@"509de852e1de55e1efa8eacfa11df0823f26f226"
variable {M : Type*} [Monoid M] {s : Set M}
variable {A : Type*} [AddMonoi... | Mathlib/Deprecated/Submonoid.lean | 232 | 237 | theorem list_prod_mem (hs : IsSubmonoid s) : ∀ {l : List M}, (∀ x ∈ l, x ∈ s) → l.prod ∈ s
| [], _ => hs.one_mem
| a :: l, h =>
suffices a * l.prod ∈ s by simpa
have : a ∈ s ∧ ∀ x ∈ l, x ∈ s := by | simpa using h
hs.mul_mem this.1 (list_prod_mem hs this.2)
| [
" a ∈ s ∧ ∀ x ∈ l, x ∈ s",
" (a :: l).prod ∈ s"
] | [] |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Algebra.Polynomial.Eval
import Mathlib.GroupTheory.GroupAction.Ring
#align_import data.polynomial.derivative from "leanprover-community/mathlib"@"bbeb185db4ccee8ed07dc48449414ebfa39cb821"
noncomputable section
open Finset
open Polynomial
namespace Pol... | Mathlib/Algebra/Polynomial/Derivative.lean | 115 | 116 | theorem derivative_X_sq : derivative (X ^ 2 : R[X]) = C 2 * X := by |
rw [derivative_X_pow, Nat.cast_two, pow_one]
| [
" (fun p => p.sum fun n a => C (a * ↑n) * X ^ (n - 1)) (p + q) =\n (fun p => p.sum fun n a => C (a * ↑n) * X ^ (n - 1)) p + (fun p => p.sum fun n a => C (a * ↑n) * X ^ (n - 1)) q",
" ((p + q).sum fun n a => C (a * ↑n) * X ^ (n - 1)) =\n (p.sum fun n a => C (a * ↑n) * X ^ (n - 1)) + q.sum fun n a => C (a * ↑... | [
" (fun p => p.sum fun n a => C (a * ↑n) * X ^ (n - 1)) (p + q) =\n (fun p => p.sum fun n a => C (a * ↑n) * X ^ (n - 1)) p + (fun p => p.sum fun n a => C (a * ↑n) * X ^ (n - 1)) q",
" ((p + q).sum fun n a => C (a * ↑n) * X ^ (n - 1)) =\n (p.sum fun n a => C (a * ↑n) * X ^ (n - 1)) + q.sum fun n a => C (a * ↑... |
import Mathlib.Data.Multiset.Nodup
#align_import data.multiset.sum from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
open Sum
namespace Multiset
variable {α β : Type*} (s : Multiset α) (t : Multiset β)
def disjSum : Multiset (Sum α β) :=
s.map inl + t.map inr
#align multiset.dis... | Mathlib/Data/Multiset/Sum.lean | 55 | 60 | theorem inl_mem_disjSum : inl a ∈ s.disjSum t ↔ a ∈ s := by |
rw [mem_disjSum, or_iff_left]
-- Porting note: Previous code for L62 was: simp only [exists_eq_right]
· simp only [inl.injEq, exists_eq_right]
rintro ⟨b, _, hb⟩
exact inr_ne_inl hb
| [
" card (s.disjSum t) = card s + card t",
" x ∈ s.disjSum t ↔ (∃ a ∈ s, inl a = x) ∨ ∃ b ∈ t, inr b = x",
" inl a ∈ s.disjSum t ↔ a ∈ s",
" (∃ a_1 ∈ s, inl a_1 = inl a) ↔ a ∈ s",
" ¬∃ b ∈ t, inr b = inl a",
" False"
] | [
" card (s.disjSum t) = card s + card t",
" x ∈ s.disjSum t ↔ (∃ a ∈ s, inl a = x) ∨ ∃ b ∈ t, inr b = x"
] |
import Mathlib.Computability.Encoding
import Mathlib.Logic.Small.List
import Mathlib.ModelTheory.Syntax
import Mathlib.SetTheory.Cardinal.Ordinal
#align_import model_theory.encoding from "leanprover-community/mathlib"@"91288e351d51b3f0748f0a38faa7613fb0ae2ada"
universe u v w u' v'
namespace FirstOrder
namespace... | Mathlib/ModelTheory/Encoding.lean | 122 | 151 | theorem card_sigma : #(Σn, L.Term (Sum α (Fin n))) = max ℵ₀ #(Sum α (Σi, L.Functions i)) := by |
refine le_antisymm ?_ ?_
· rw [mk_sigma]
refine (sum_le_iSup_lift _).trans ?_
rw [mk_nat, lift_aleph0, mul_eq_max_of_aleph0_le_left le_rfl, max_le_iff,
ciSup_le_iff' (bddAbove_range _)]
· refine ⟨le_max_left _ _, fun i => card_le.trans ?_⟩
refine max_le (le_max_left _ _) ?_
rw [← add_... | [
" listDecode (l.bind listEncode) = List.map some l",
" listDecode ([].bind listEncode) = List.map some []",
" listDecode ((t :: l).bind listEncode) = List.map some (t :: l)",
" ∀ (t : L.Term α) (l : List (α ⊕ (i : ℕ) × L.Functions i)), listDecode (t.listEncode ++ l) = some t :: listDecode l",
" ∀ (l : List ... | [
" listDecode (l.bind listEncode) = List.map some l",
" listDecode ([].bind listEncode) = List.map some []",
" listDecode ((t :: l).bind listEncode) = List.map some (t :: l)",
" ∀ (t : L.Term α) (l : List (α ⊕ (i : ℕ) × L.Functions i)), listDecode (t.listEncode ++ l) = some t :: listDecode l",
" ∀ (l : List ... |
import Mathlib.Data.Set.Basic
open Function
universe u v
namespace Set
section Subsingleton
variable {α : Type u} {a : α} {s t : Set α}
protected def Subsingleton (s : Set α) : Prop :=
∀ ⦃x⦄ (_ : x ∈ s) ⦃y⦄ (_ : y ∈ s), x = y
#align set.subsingleton Set.Subsingleton
theorem Subsingleton.anti (ht : t.Subs... | Mathlib/Data/Set/Subsingleton.lean | 99 | 104 | theorem exists_eq_singleton_iff_nonempty_subsingleton :
(∃ a : α, s = {a}) ↔ s.Nonempty ∧ s.Subsingleton := by |
refine ⟨?_, fun h => ?_⟩
· rintro ⟨a, rfl⟩
exact ⟨singleton_nonempty a, subsingleton_singleton⟩
· exact h.2.eq_empty_or_singleton.resolve_left h.1.ne_empty
| [
" p s",
" p {x}",
" (∃ a, s = {a}) ↔ s.Nonempty ∧ s.Subsingleton",
" (∃ a, s = {a}) → s.Nonempty ∧ s.Subsingleton",
" {a}.Nonempty ∧ {a}.Subsingleton",
" ∃ a, s = {a}"
] | [
" p s",
" p {x}"
] |
import Mathlib.Dynamics.Ergodic.MeasurePreserving
import Mathlib.LinearAlgebra.Determinant
import Mathlib.LinearAlgebra.Matrix.Diagonal
import Mathlib.LinearAlgebra.Matrix.Transvection
import Mathlib.MeasureTheory.Group.LIntegral
import Mathlib.MeasureTheory.Integral.Marginal
import Mathlib.MeasureTheory.Measure.Stiel... | Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean | 96 | 96 | theorem volume_singleton {a : ℝ} : volume ({a} : Set ℝ) = 0 := by | simp [volume_val]
| [
" volume = StieltjesFunction.id.measure",
" StieltjesFunction.id.measure (Ioo ↑p ↑q) = (Measure.map (fun x => a + x) StieltjesFunction.id.measure) (Ioo ↑p ↑q)",
" StieltjesFunction.id.measure ↑(stdOrthonormalBasis ℝ ℝ).toBasis.parallelepiped = 1",
" StieltjesFunction.id.measure (parallelepiped ⇑(stdOrthonorma... | [
" volume = StieltjesFunction.id.measure",
" StieltjesFunction.id.measure (Ioo ↑p ↑q) = (Measure.map (fun x => a + x) StieltjesFunction.id.measure) (Ioo ↑p ↑q)",
" StieltjesFunction.id.measure ↑(stdOrthonormalBasis ℝ ℝ).toBasis.parallelepiped = 1",
" StieltjesFunction.id.measure (parallelepiped ⇑(stdOrthonorma... |
import Mathlib.LinearAlgebra.Dimension.Finite
import Mathlib.LinearAlgebra.Dimension.Constructions
open Cardinal Submodule Set FiniteDimensional
universe u v
namespace Subalgebra
variable {F E : Type*} [CommRing F] [StrongRankCondition F] [Ring E] [Algebra F E]
{S : Subalgebra F E}
theorem eq_bot_of_rank_le_o... | Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean | 284 | 295 | theorem rank_eq_one_iff [Nontrivial E] [Module.Free F S] : Module.rank F S = 1 ↔ S = ⊥ := by |
refine ⟨fun h ↦ Subalgebra.eq_bot_of_rank_le_one h.le, ?_⟩
rintro rfl
obtain ⟨κ, b⟩ := Module.Free.exists_basis (R := F) (M := (⊥ : Subalgebra F E))
refine le_antisymm ?_ ?_
· have := lift_rank_range_le (Algebra.linearMap F E)
rwa [← one_eq_range, rank_self, lift_one, lift_le_one_iff] at this
· by_cont... | [
" S = ⊥",
" x ∈ range ⇑(algebraMap F E)",
" Module.rank F ↥S ≤ 1",
" Module.rank F ↥S = 1 ↔ S = ⊥",
" S = ⊥ → Module.rank F ↥S = 1",
" Module.rank F ↥⊥ = 1",
" Module.rank F ↥⊥ ≤ 1",
" 1 ≤ Module.rank F ↥⊥",
" False"
] | [
" S = ⊥",
" x ∈ range ⇑(algebraMap F E)",
" Module.rank F ↥S ≤ 1"
] |
import Mathlib.Algebra.Field.Subfield
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Topology.Algebra.GroupWithZero
import Mathlib.Topology.Algebra.Ring.Basic
import Mathlib.Topology.Order.LocalExtr
#align_import topology.algebra.field from "leanprover-community/mathlib"@"c10e724be91096453ee3db13862... | Mathlib/Topology/Algebra/Field.lean | 112 | 114 | theorem IsLocalMin.inv {f : α → β} {a : α} (h1 : IsLocalMin f a) (h2 : ∀ᶠ z in 𝓝 a, 0 < f z) :
IsLocalMax f⁻¹ a := by |
filter_upwards [h1, h2] with z h3 h4 using(inv_le_inv h4 h2.self_of_nhds).mpr h3
| [
" IsLocalMax f⁻¹ a"
] | [] |
import Mathlib.MeasureTheory.Integral.Bochner
import Mathlib.MeasureTheory.Group.Measure
#align_import measure_theory.group.integration from "leanprover-community/mathlib"@"ec247d43814751ffceb33b758e8820df2372bf6f"
namespace MeasureTheory
open Measure TopologicalSpace
open scoped ENNReal
variable {𝕜 M α G E F ... | Mathlib/MeasureTheory/Group/Integral.lean | 165 | 168 | theorem integral_smul_eq_self {μ : Measure α} [SMulInvariantMeasure G α μ] (f : α → E) {g : G} :
(∫ x, f (g • x) ∂μ) = ∫ x, f x ∂μ := by |
have h : MeasurableEmbedding fun x : α => g • x := (MeasurableEquiv.smul g).measurableEmbedding
rw [← h.integral_map, map_smul]
| [
" ∫ (x : α), f (g • x) ∂μ = ∫ (x : α), f x ∂μ"
] | [] |
import Mathlib.CategoryTheory.Balanced
import Mathlib.CategoryTheory.Limits.EssentiallySmall
import Mathlib.CategoryTheory.Limits.Opposites
import Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms
import Mathlib.CategoryTheory.Subobject.Lattice
import Mathlib.CategoryTheory.Subobject.WellPowered
import Mathlib.Data.S... | Mathlib/CategoryTheory/Generator.lean | 93 | 98 | theorem isSeparating_op_iff (𝒢 : Set C) : IsSeparating 𝒢.op ↔ IsCoseparating 𝒢 := by |
refine ⟨fun h𝒢 X Y f g hfg => ?_, fun h𝒢 X Y f g hfg => ?_⟩
· refine Quiver.Hom.op_inj (h𝒢 _ _ fun G hG h => Quiver.Hom.unop_inj ?_)
simpa only [unop_comp, Quiver.Hom.unop_op] using hfg _ (Set.mem_op.1 hG) _
· refine Quiver.Hom.unop_inj (h𝒢 _ _ fun G hG h => Quiver.Hom.op_inj ?_)
simpa only [op_comp,... | [
" IsSeparating 𝒢.op ↔ IsCoseparating 𝒢",
" f = g",
" (h ≫ f.op).unop = (h ≫ g.op).unop",
" (f.unop ≫ h).op = (g.unop ≫ h).op"
] | [] |
import Mathlib.Order.Interval.Set.Basic
import Mathlib.Order.Hom.Set
#align_import data.set.intervals.order_iso from "leanprover-community/mathlib"@"d012cd09a9b256d870751284dd6a29882b0be105"
open Set
namespace OrderIso
section Preorder
variable {α β : Type*} [Preorder α] [Preorder β]
@[simp]
theorem preimage_I... | Mathlib/Order/Interval/Set/OrderIso.lean | 98 | 99 | theorem image_Ico (e : α ≃o β) (a b : α) : e '' Ico a b = Ico (e a) (e b) := by |
rw [e.image_eq_preimage, e.symm.preimage_Ico, e.symm_symm]
| [
" ⇑e ⁻¹' Iic b = Iic (e.symm b)",
" x ∈ ⇑e ⁻¹' Iic b ↔ x ∈ Iic (e.symm b)",
" ⇑e ⁻¹' Ici b = Ici (e.symm b)",
" x ∈ ⇑e ⁻¹' Ici b ↔ x ∈ Ici (e.symm b)",
" ⇑e ⁻¹' Iio b = Iio (e.symm b)",
" x ∈ ⇑e ⁻¹' Iio b ↔ x ∈ Iio (e.symm b)",
" ⇑e ⁻¹' Ioi b = Ioi (e.symm b)",
" x ∈ ⇑e ⁻¹' Ioi b ↔ x ∈ Ioi (e.symm b)"... | [
" ⇑e ⁻¹' Iic b = Iic (e.symm b)",
" x ∈ ⇑e ⁻¹' Iic b ↔ x ∈ Iic (e.symm b)",
" ⇑e ⁻¹' Ici b = Ici (e.symm b)",
" x ∈ ⇑e ⁻¹' Ici b ↔ x ∈ Ici (e.symm b)",
" ⇑e ⁻¹' Iio b = Iio (e.symm b)",
" x ∈ ⇑e ⁻¹' Iio b ↔ x ∈ Iio (e.symm b)",
" ⇑e ⁻¹' Ioi b = Ioi (e.symm b)",
" x ∈ ⇑e ⁻¹' Ioi b ↔ x ∈ Ioi (e.symm b)"... |
import Mathlib.Analysis.InnerProductSpace.TwoDim
import Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic
#align_import geometry.euclidean.angle.oriented.basic from "leanprover-community/mathlib"@"f0c8bf9245297a541f468be517f1bde6195105e9"
noncomputable section
open FiniteDimensional Complex
open scoped Real Rea... | Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean | 68 | 68 | theorem oangle_zero_left (x : V) : o.oangle 0 x = 0 := by | simp [oangle]
| [
" ContinuousAt (fun y => o.oangle y.1 y.2) x",
" (o.kahler x.1) x.2 ≠ 0",
" ContinuousAt (fun y => (o.kahler y.1) y.2) x",
" o.oangle 0 x = 0"
] | [
" ContinuousAt (fun y => o.oangle y.1 y.2) x",
" (o.kahler x.1) x.2 ≠ 0",
" ContinuousAt (fun y => (o.kahler y.1) y.2) x"
] |
import Mathlib.Algebra.MonoidAlgebra.Degree
import Mathlib.Algebra.Polynomial.Coeff
import Mathlib.Algebra.Polynomial.Monomial
import Mathlib.Data.Fintype.BigOperators
import Mathlib.Data.Nat.WithBot
import Mathlib.Data.Nat.Cast.WithTop
import Mathlib.Data.Nat.SuccPred
#align_import data.polynomial.degree.definitions... | Mathlib/Algebra/Polynomial/Degree/Definitions.lean | 128 | 129 | theorem natDegree_of_subsingleton [Subsingleton R] : natDegree p = 0 := by |
rw [Subsingleton.elim p 0, natDegree_zero]
| [
" Decidable p.Monic",
" Decidable (p.leadingCoeff = 1)",
" p.degree = ⊥",
" p.natDegree = 0"
] | [
" Decidable p.Monic",
" Decidable (p.leadingCoeff = 1)",
" p.degree = ⊥"
] |
import Mathlib.Algebra.GCDMonoid.Basic
import Mathlib.RingTheory.IntegrallyClosed
import Mathlib.RingTheory.Polynomial.Eisenstein.Basic
#align_import algebra.gcd_monoid.integrally_closed from "leanprover-community/mathlib"@"2032a878972d5672e7c27c957e7a6e297b044973"
open scoped Polynomial
variable {R A : Type*} [... | Mathlib/Algebra/GCDMonoid/IntegrallyClosed.lean | 23 | 30 | theorem IsLocalization.surj_of_gcd_domain [GCDMonoid R] (M : Submonoid R) [IsLocalization M A]
(z : A) : ∃ a b : R, IsUnit (gcd a b) ∧ z * algebraMap R A b = algebraMap R A a := by |
obtain ⟨x, ⟨y, hy⟩, rfl⟩ := IsLocalization.mk'_surjective M z
obtain ⟨x', y', hx', hy', hu⟩ := extract_gcd x y
use x', y', hu
rw [mul_comm, IsLocalization.mul_mk'_eq_mk'_of_mul]
convert IsLocalization.mk'_mul_cancel_left (M := M) (S := A) _ _ using 2
rw [Subtype.coe_mk, hy', ← mul_comm y', mul_assoc]; conv... | [
" ∃ a b, IsUnit (gcd a b) ∧ z * (algebraMap R A) b = (algebraMap R A) a",
" ∃ a b, IsUnit (gcd a b) ∧ mk' A x ⟨y, hy⟩ * (algebraMap R A) b = (algebraMap R A) a",
" mk' A x ⟨y, hy⟩ * (algebraMap R A) y' = (algebraMap R A) x'",
" mk' A (y' * x) ⟨y, hy⟩ = (algebraMap R A) x'",
" y' * x = ↑⟨y, hy⟩ * x'",
" y'... | [] |
import Mathlib.LinearAlgebra.Dimension.Finite
import Mathlib.LinearAlgebra.Dimension.Constructions
open Cardinal Submodule Set FiniteDimensional
universe u v
namespace Subalgebra
variable {F E : Type*} [CommRing F] [StrongRankCondition F] [Ring E] [Algebra F E]
{S : Subalgebra F E}
| Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean | 262 | 274 | theorem eq_bot_of_rank_le_one (h : Module.rank F S ≤ 1) [Module.Free F S] : S = ⊥ := by |
nontriviality E
obtain ⟨κ, b⟩ := Module.Free.exists_basis (R := F) (M := S)
by_cases h1 : Module.rank F S = 1
· refine bot_unique fun x hx ↦ Algebra.mem_bot.2 ?_
rw [← b.mk_eq_rank'', eq_one_iff_unique, ← unique_iff_subsingleton_and_nonempty] at h1
obtain ⟨h1⟩ := h1
obtain ⟨y, hy⟩ := (bijective_alg... | [
" S = ⊥",
" x ∈ range ⇑(algebraMap F E)"
] | [] |
import Mathlib.LinearAlgebra.Matrix.DotProduct
import Mathlib.LinearAlgebra.Determinant
import Mathlib.LinearAlgebra.Matrix.Diagonal
#align_import data.matrix.rank from "leanprover-community/mathlib"@"17219820a8aa8abe85adf5dfde19af1dd1bd8ae7"
open Matrix
namespace Matrix
open FiniteDimensional
variable {l m n ... | Mathlib/Data/Matrix/Rank.lean | 140 | 142 | theorem rank_submatrix [Fintype m] (A : Matrix m m R) (e₁ e₂ : n ≃ m) :
rank (A.submatrix e₁ e₂) = rank A := by |
simpa only [reindex_apply] using rank_reindex e₁.symm e₂.symm A
| [
" rank 1 = Fintype.card n",
" rank 0 = 0",
" A.rank ≤ Fintype.card n",
" (A * B).rank ≤ A.rank",
" finrank R ↥(LinearMap.range (A.mulVecLin ∘ₗ B.mulVecLin)) ≤ finrank R ↥(LinearMap.range A.mulVecLin)",
" (A * B).rank ≤ B.rank",
" finrank R ↥(LinearMap.range (A.mulVecLin ∘ₗ B.mulVecLin)) ≤ finrank R ↥(Li... | [
" rank 1 = Fintype.card n",
" rank 0 = 0",
" A.rank ≤ Fintype.card n",
" (A * B).rank ≤ A.rank",
" finrank R ↥(LinearMap.range (A.mulVecLin ∘ₗ B.mulVecLin)) ≤ finrank R ↥(LinearMap.range A.mulVecLin)",
" (A * B).rank ≤ B.rank",
" finrank R ↥(LinearMap.range (A.mulVecLin ∘ₗ B.mulVecLin)) ≤ finrank R ↥(Li... |
import Mathlib.Analysis.Calculus.ContDiff.Basic
import Mathlib.Analysis.Calculus.Deriv.Linear
import Mathlib.Analysis.Complex.Conformal
import Mathlib.Analysis.Calculus.Conformal.NormedSpace
#align_import analysis.complex.real_deriv from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
se... | Mathlib/Analysis/Complex/RealDeriv.lean | 171 | 185 | theorem conformalAt_iff_differentiableAt_or_differentiableAt_comp_conj {f : ℂ → ℂ} {z : ℂ} :
ConformalAt f z ↔
(DifferentiableAt ℂ f z ∨ DifferentiableAt ℂ (f ∘ conj) (conj z)) ∧ fderiv ℝ f z ≠ 0 := by |
rw [conformalAt_iff_isConformalMap_fderiv]
rw [isConformalMap_iff_is_complex_or_conj_linear]
apply and_congr_left
intro h
have h_diff := h.imp_symm fderiv_zero_of_not_differentiableAt
apply or_congr
· rw [differentiableAt_iff_restrictScalars ℝ h_diff]
rw [← conj_conj z] at h_diff
rw [differentiableAt... | [
" ConformalAt f z",
" IsConformalMap (ContinuousLinearMap.restrictScalars ℝ (fderiv ℂ f z))",
" fderiv ℂ f z ≠ 0",
" ConformalAt f z ↔\n (DifferentiableAt ℂ f z ∨ DifferentiableAt ℂ (f ∘ ⇑(starRingEnd ℂ)) ((starRingEnd ℂ) z)) ∧ fderiv ℝ f z ≠ 0",
" IsConformalMap (fderiv ℝ f z) ↔\n (DifferentiableAt ℂ... | [
" ConformalAt f z",
" IsConformalMap (ContinuousLinearMap.restrictScalars ℝ (fderiv ℂ f z))",
" fderiv ℂ f z ≠ 0"
] |
import Mathlib.Topology.MetricSpace.HausdorffDistance
import Mathlib.MeasureTheory.Constructions.BorelSpace.Order
#align_import measure_theory.measure.regular from "leanprover-community/mathlib"@"bf6a01357ff5684b1ebcd0f1a13be314fc82c0bf"
open Set Filter ENNReal Topology NNReal TopologicalSpace
namespace MeasureTh... | Mathlib/MeasureTheory/Measure/Regular.lean | 361 | 366 | theorem _root_.Set.exists_isOpen_le_add (A : Set α) (μ : Measure α) [OuterRegular μ] {ε : ℝ≥0∞}
(hε : ε ≠ 0) : ∃ U, U ⊇ A ∧ IsOpen U ∧ μ U ≤ μ A + ε := by |
rcases eq_or_ne (μ A) ∞ with (H | H)
· exact ⟨univ, subset_univ _, isOpen_univ, by simp only [H, _root_.top_add, le_top]⟩
· rcases A.exists_isOpen_lt_add H hε with ⟨U, AU, U_open, hU⟩
exact ⟨U, AU, U_open, hU.le⟩
| [
" ∃ U ⊇ A, IsOpen U ∧ μ U < r",
" r > ?m.3205 (toMeasurable μ A)",
" μ A = ⨅ U, ⨅ (_ : A ⊆ U), ⨅ (_ : IsOpen U), μ U",
" ⨅ U, ⨅ (_ : A ⊆ U), ⨅ (_ : IsOpen U), μ U ≤ μ A",
" ⨅ U, ⨅ (_ : A ⊆ U), ⨅ (_ : IsOpen U), μ U < r",
" ∃ U ⊇ A, IsOpen U ∧ μ U ≤ μ A + ε",
" μ univ ≤ μ A + ε"
] | [
" ∃ U ⊇ A, IsOpen U ∧ μ U < r",
" r > ?m.3205 (toMeasurable μ A)",
" μ A = ⨅ U, ⨅ (_ : A ⊆ U), ⨅ (_ : IsOpen U), μ U",
" ⨅ U, ⨅ (_ : A ⊆ U), ⨅ (_ : IsOpen U), μ U ≤ μ A",
" ⨅ U, ⨅ (_ : A ⊆ U), ⨅ (_ : IsOpen U), μ U < r"
] |
import Mathlib.Probability.IdentDistrib
import Mathlib.MeasureTheory.Integral.DominatedConvergence
import Mathlib.Analysis.SpecificLimits.FloorPow
import Mathlib.Analysis.PSeries
import Mathlib.Analysis.Asymptotics.SpecificAsymptotics
#align_import probability.strong_law from "leanprover-community/mathlib"@"f2ce60867... | Mathlib/Probability/StrongLaw.lean | 106 | 111 | theorem truncation_eq_self {f : α → ℝ} {A : ℝ} {x : α} (h : |f x| < A) :
truncation f A x = f x := by |
simp only [truncation, indicator, Set.mem_Icc, id, Function.comp_apply, ite_eq_left_iff]
intro H
apply H.elim
simp [(abs_lt.1 h).1, (abs_lt.1 h).2.le]
| [
" AEStronglyMeasurable (ProbabilityTheory.truncation f A) μ",
" AEStronglyMeasurable ((Set.Ioc (-A) A).indicator id) (Measure.map f μ)",
" |truncation f A x| ≤ |A|",
" |if f x ∈ Set.Ioc (-A) A then f x else 0| ≤ |A|",
" |f x| ≤ |A|",
" |0| ≤ |A|",
" truncation f 0 = 0",
" (fun x => 0) ∘ f = 0",
" |t... | [
" AEStronglyMeasurable (ProbabilityTheory.truncation f A) μ",
" AEStronglyMeasurable ((Set.Ioc (-A) A).indicator id) (Measure.map f μ)",
" |truncation f A x| ≤ |A|",
" |if f x ∈ Set.Ioc (-A) A then f x else 0| ≤ |A|",
" |f x| ≤ |A|",
" |0| ≤ |A|",
" truncation f 0 = 0",
" (fun x => 0) ∘ f = 0",
" |t... |
import Mathlib.Order.Filter.Bases
#align_import order.filter.pi from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
open Set Function
open scoped Classical
open Filter
namespace Filter
variable {ι : Type*} {α : ι → Type*} {f f₁ f₂ : (i : ι) → Filter (α i)} {s : (i : ι) → Set (α i)}
... | Mathlib/Order/Filter/Pi.lean | 229 | 230 | theorem mem_coprodᵢ_iff {s : Set (∀ i, α i)} :
s ∈ Filter.coprodᵢ f ↔ ∀ i : ι, ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ s := by | simp [Filter.coprodᵢ]
| [
" s ∈ Filter.coprodᵢ f ↔ ∀ (i : ι), ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ s"
] | [] |
import Batteries.Data.Fin.Basic
namespace Fin
attribute [norm_cast] val_last
protected theorem le_antisymm_iff {x y : Fin n} : x = y ↔ x ≤ y ∧ y ≤ x :=
Fin.ext_iff.trans Nat.le_antisymm_iff
protected theorem le_antisymm {x y : Fin n} (h1 : x ≤ y) (h2 : y ≤ x) : x = y :=
Fin.le_antisymm_iff.2 ⟨h1, h2⟩
@[simp... | .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean | 87 | 90 | theorem foldl_eq_foldl_list (f : α → Fin n → α) (x) : foldl n f x = (list n).foldl f x := by |
induction n generalizing x with
| zero => rw [foldl_zero, list_zero, List.foldl_nil]
| succ n ih => rw [foldl_succ, ih, list_succ, List.foldl_cons, List.foldl_map]
| [
" enum 0 = #[]",
" (list n).length = n",
" (list n).get i = cast ⋯ i",
" (list n).get ⟨val✝, isLt✝⟩ = cast ⋯ ⟨val✝, isLt✝⟩",
" (enum n).data.get ⟨val✝, isLt✝⟩ = cast ⋯ ⟨val✝, isLt✝⟩",
" list 0 = []",
" list (n + 1) = 0 :: List.map succ (list n)",
" ∀ (n_1 : Nat) (h₁ : n_1 < (list (n + 1)).length) (h₂ ... | [
" enum 0 = #[]",
" (list n).length = n",
" (list n).get i = cast ⋯ i",
" (list n).get ⟨val✝, isLt✝⟩ = cast ⋯ ⟨val✝, isLt✝⟩",
" (enum n).data.get ⟨val✝, isLt✝⟩ = cast ⋯ ⟨val✝, isLt✝⟩",
" list 0 = []",
" list (n + 1) = 0 :: List.map succ (list n)",
" ∀ (n_1 : Nat) (h₁ : n_1 < (list (n + 1)).length) (h₂ ... |
import Mathlib.LinearAlgebra.AffineSpace.AffineMap
import Mathlib.Tactic.FieldSimp
#align_import linear_algebra.affine_space.slope from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
open AffineMap
variable {k E PE : Type*} [Field k] [AddCommGroup E] [Module k E] [AddTorsor E PE]
def ... | Mathlib/LinearAlgebra/AffineSpace/Slope.lean | 121 | 124 | theorem lineMap_slope_slope_sub_div_sub (f : k → PE) (a b c : k) (h : a ≠ c) :
lineMap (slope f a b) (slope f b c) ((c - b) / (c - a)) = slope f a c := by |
field_simp [sub_ne_zero.2 h.symm, ← sub_div_sub_smul_slope_add_sub_div_sub_smul_slope f a b c,
lineMap_apply_module]
| [
" slope f a a = 0",
" (b - a) • slope f a b = f b -ᵥ f a",
" (a - a) • slope f a a = f a -ᵥ f a",
" (b - a) • slope f a b +ᵥ f a = f b",
" (slope fun x => f x +ᵥ c) = slope f",
" slope (fun x => f x +ᵥ c) a b = slope f a b",
" slope (fun x => (x - a) • f x) a b = f b",
" f a = f b",
" slope (⇑f ∘ g)... | [
" slope f a a = 0",
" (b - a) • slope f a b = f b -ᵥ f a",
" (a - a) • slope f a a = f a -ᵥ f a",
" (b - a) • slope f a b +ᵥ f a = f b",
" (slope fun x => f x +ᵥ c) = slope f",
" slope (fun x => f x +ᵥ c) a b = slope f a b",
" slope (fun x => (x - a) • f x) a b = f b",
" f a = f b",
" slope (⇑f ∘ g)... |
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.BigOperators.Ring.List
import Mathlib.Data.Int.ModEq
import Mathlib.Data.Nat.Bits
import Mathlib.Data.Nat.Log
import Mathlib.Data.List.Indexes
import Mathlib.Data.List.Palindrome
import Mathlib.Tactic.IntervalCases
import Mathlib.Tactic.Linarith
impo... | Mathlib/Data/Nat/Digits.lean | 167 | 172 | theorem ofDigits_eq_foldr {α : Type*} [Semiring α] (b : α) (L : List ℕ) :
ofDigits b L = List.foldr (fun x y => ↑x + b * y) 0 L := by |
induction' L with d L ih
· rfl
· dsimp [ofDigits]
rw [ih]
| [
" (invImage (fun x => x) instWellFoundedRelationOfSizeOf).1 ((n + 1) / b) n.succ",
" b.digitsAux h 0 = []",
" b.digitsAux h n = n % b :: b.digitsAux h (n / b)",
" b.digitsAux h 0 = 0 % b :: b.digitsAux h (0 / b)",
" b.digitsAux h (n✝ + 1) = (n✝ + 1) % b :: b.digitsAux h ((n✝ + 1) / b)",
" 2 ≤ b + 2",
" ... | [
" (invImage (fun x => x) instWellFoundedRelationOfSizeOf).1 ((n + 1) / b) n.succ",
" b.digitsAux h 0 = []",
" b.digitsAux h n = n % b :: b.digitsAux h (n / b)",
" b.digitsAux h 0 = 0 % b :: b.digitsAux h (0 / b)",
" b.digitsAux h (n✝ + 1) = (n✝ + 1) % b :: b.digitsAux h ((n✝ + 1) / b)",
" 2 ≤ b + 2",
" ... |
import Mathlib.Data.Set.Lattice
#align_import data.set.intervals.disjoint from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
universe u v w
variable {ι : Sort u} {α : Type v} {β : Type w}
open Set
open OrderDual (toDual)
namespace Set
section Preorder
variable [Preorder α] {a b c... | Mathlib/Order/Interval/Set/Disjoint.lean | 122 | 123 | theorem iUnion_Ioo_right [NoMaxOrder α] (a : α) : ⋃ b, Ioo a b = Ioi a := by |
simp only [← Ioi_inter_Iio, ← inter_iUnion, iUnion_Iio, inter_univ]
| [
" Disjoint (Ici a) (Iic b) ↔ ¬a ≤ b",
" ⋃ b, Icc a b = Ici a",
" ⋃ b, Ioc a b = Ioi a",
" ⋃ a, Icc a b = Iic b",
" ⋃ a, Ico a b = Iio b",
" ⋃ b, Ico a b = Ici a",
" ⋃ b, Ioo a b = Ioi a"
] | [
" Disjoint (Ici a) (Iic b) ↔ ¬a ≤ b",
" ⋃ b, Icc a b = Ici a",
" ⋃ b, Ioc a b = Ioi a",
" ⋃ a, Icc a b = Iic b",
" ⋃ a, Ico a b = Iio b",
" ⋃ b, Ico a b = Ici a"
] |
import Mathlib.Probability.Notation
import Mathlib.Probability.Integration
import Mathlib.MeasureTheory.Function.L2Space
#align_import probability.variance from "leanprover-community/mathlib"@"f0c8bf9245297a541f468be517f1bde6195105e9"
open MeasureTheory Filter Finset
noncomputable section
open scoped MeasureThe... | Mathlib/Probability/Variance.lean | 100 | 103 | theorem _root_.MeasureTheory.Memℒp.ofReal_variance_eq [IsFiniteMeasure μ] (hX : Memℒp X 2 μ) :
ENNReal.ofReal (variance X μ) = evariance X μ := by |
rw [variance, ENNReal.ofReal_toReal]
exact hX.evariance_lt_top.ne
| [
" evariance X μ < ⊤",
" evariance X μ = ⊤",
" False",
" Memℒp (fun ω => X ω - ∫ (x : Ω), X x ∂μ) 2 μ",
" snorm (fun ω => X ω - ∫ (x : Ω), X x ∂μ) 2 μ < ⊤",
" (∫⁻ (x : Ω), ↑‖X x - ∫ (x : Ω), X x ∂μ‖₊ ^ ENNReal.toReal 2 ∂μ) ^ (1 / ENNReal.toReal 2) < ⊤",
" (∫⁻ (x : Ω), ↑‖X x - ∫ (x : Ω), X x ∂μ‖₊ ^ 2 ∂μ) ... | [
" evariance X μ < ⊤",
" evariance X μ = ⊤",
" False",
" Memℒp (fun ω => X ω - ∫ (x : Ω), X x ∂μ) 2 μ",
" snorm (fun ω => X ω - ∫ (x : Ω), X x ∂μ) 2 μ < ⊤",
" (∫⁻ (x : Ω), ↑‖X x - ∫ (x : Ω), X x ∂μ‖₊ ^ ENNReal.toReal 2 ∂μ) ^ (1 / ENNReal.toReal 2) < ⊤",
" (∫⁻ (x : Ω), ↑‖X x - ∫ (x : Ω), X x ∂μ‖₊ ^ 2 ∂μ) ... |
import Mathlib.Data.Complex.Basic
import Mathlib.Data.Real.Sqrt
#align_import data.complex.basic from "leanprover-community/mathlib"@"31c24aa72e7b3e5ed97a8412470e904f82b81004"
open Set ComplexConjugate
namespace Complex
namespace AbsTheory
-- We develop enough theory to bundle `abs` into an `AbsoluteValue` be... | Mathlib/Data/Complex/Abs.lean | 34 | 34 | theorem abs_conj (z : ℂ) : (abs conj z) = abs z := by | simp
| [
" (abs(starRingEnd ℂ) z) = abs z"
] | [] |
import Mathlib.Algebra.Ring.Prod
import Mathlib.GroupTheory.OrderOfElement
import Mathlib.Tactic.FinCases
#align_import data.zmod.basic from "leanprover-community/mathlib"@"74ad1c88c77e799d2fea62801d1dbbd698cff1b7"
assert_not_exists Submodule
open Function
namespace ZMod
instance charZero : CharZero (ZMod 0) :=... | Mathlib/Data/ZMod/Basic.lean | 84 | 88 | theorem val_natCast {n : ℕ} (a : ℕ) : (a : ZMod n).val = a % n := by |
cases n
· rw [Nat.mod_zero]
exact Int.natAbs_ofNat a
· apply Fin.val_natCast
| [
" a.val < n",
" a.val < 0",
" a.val < n✝ + 1",
" (↑a).val = a % n",
" (↑a).val = a % 0",
" (↑a).val = a",
" (↑a).val = a % (n✝ + 1)"
] | [
" a.val < n",
" a.val < 0",
" a.val < n✝ + 1"
] |
import Mathlib.Analysis.Convex.Between
import Mathlib.Analysis.Convex.Jensen
import Mathlib.Analysis.Convex.Topology
import Mathlib.Analysis.Normed.Group.Pointwise
import Mathlib.Analysis.NormedSpace.AddTorsor
#align_import analysis.convex.normed from "leanprover-community/mathlib"@"a63928c34ec358b5edcda2bf7513c50052... | Mathlib/Analysis/Convex/Normed.lean | 66 | 67 | theorem convex_closedBall (a : E) (r : ℝ) : Convex ℝ (Metric.closedBall a r) := by |
simpa only [Metric.closedBall, sep_univ] using (convexOn_univ_dist a).convex_le r
| [
" ‖a • x‖ + ‖b • y‖ = a * ‖x‖ + b * ‖y‖",
" ConvexOn ℝ s fun z' => dist z' z",
" Convex ℝ (ball a r)",
" Convex ℝ (closedBall a r)"
] | [
" ‖a • x‖ + ‖b • y‖ = a * ‖x‖ + b * ‖y‖",
" ConvexOn ℝ s fun z' => dist z' z",
" Convex ℝ (ball a r)"
] |
import Mathlib.Algebra.Group.Basic
import Mathlib.Algebra.Group.Hom.Defs
#align_import algebra.hom.group from "leanprover-community/mathlib"@"a148d797a1094ab554ad4183a4ad6f130358ef64"
-- `NeZero` cannot be additivised, hence its theory should be developed outside of the
-- `Algebra.Group` folder.
assert_not_exists... | Mathlib/Algebra/Group/Hom/Basic.lean | 110 | 113 | theorem comp_mul [Mul M] [CommSemigroup N] [CommSemigroup P] (g : N →ₙ* P) (f₁ f₂ : M →ₙ* N) :
g.comp (f₁ * f₂) = g.comp f₁ * g.comp f₂ := by |
ext
simp only [mul_apply, Function.comp_apply, map_mul, coe_comp]
| [
" (fun m => f m * g m) (x * y) = (fun m => f m * g m) x * (fun m => f m * g m) y",
" f (x * y) * g (x * y) = f x * g x * (f y * g y)",
" g.comp (f₁ * f₂) = g.comp f₁ * g.comp f₂",
" (g.comp (f₁ * f₂)) x✝ = (g.comp f₁ * g.comp f₂) x✝"
] | [
" (fun m => f m * g m) (x * y) = (fun m => f m * g m) x * (fun m => f m * g m) y",
" f (x * y) * g (x * y) = f x * g x * (f y * g y)"
] |
import Mathlib.Algebra.Algebra.Defs
import Mathlib.Algebra.Order.Group.Basic
import Mathlib.Algebra.Order.Ring.Basic
import Mathlib.RingTheory.Localization.Basic
import Mathlib.SetTheory.Game.Birthday
import Mathlib.SetTheory.Surreal.Basic
#align_import set_theory.surreal.dyadic from "leanprover-community/mathlib"@"9... | Mathlib/SetTheory/Surreal/Dyadic.lean | 124 | 156 | theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by |
induction' n using Nat.strong_induction_on with n hn
constructor <;> rw [le_iff_forall_lf] <;> constructor
· rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
· calc
0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
_ < powHalf n := powHalf_succ_lt_powHalf n
· calc
powHalf n.succ + 0 ... | [
" (powHalf n).LeftMoves = PUnit.{u_1 + 1}",
" (powHalf 0).LeftMoves = PUnit.{u_1 + 1}",
" (powHalf (n✝ + 1)).LeftMoves = PUnit.{u_1 + 1}",
" (powHalf n).moveLeft i = 0",
" (powHalf 0).moveLeft i = 0",
" (powHalf (n✝ + 1)).moveLeft i = 0",
" (powHalf 0).moveLeft PUnit.unit = 0",
" (powHalf (n✝ + 1)).mo... | [
" (powHalf n).LeftMoves = PUnit.{u_1 + 1}",
" (powHalf 0).LeftMoves = PUnit.{u_1 + 1}",
" (powHalf (n✝ + 1)).LeftMoves = PUnit.{u_1 + 1}",
" (powHalf n).moveLeft i = 0",
" (powHalf 0).moveLeft i = 0",
" (powHalf (n✝ + 1)).moveLeft i = 0",
" (powHalf 0).moveLeft PUnit.unit = 0",
" (powHalf (n✝ + 1)).mo... |
import Mathlib.Topology.Order.Basic
open Set Filter OrderDual
open scoped Topology
section OrderClosedTopology
variable {α : Type*} [LinearOrder α] [TopologicalSpace α] [OrderClosedTopology α] {a b c d : α}
@[simp] theorem nhdsSet_Ioi : 𝓝ˢ (Ioi a) = 𝓟 (Ioi a) := isOpen_Ioi.nhdsSet_eq
@[simp] theorem nhdsSet... | Mathlib/Topology/Order/NhdsSet.lean | 41 | 42 | theorem nhdsSet_Ico (h : a < b) : 𝓝ˢ (Ico a b) = 𝓝 a ⊔ 𝓟 (Ioo a b) := by |
rw [← Ioo_insert_left h, nhdsSet_insert, nhdsSet_Ioo]
| [
" 𝓝ˢ (Ici a) = 𝓝 a ⊔ 𝓟 (Ioi a)",
" 𝓝ˢ (Ico a b) = 𝓝 a ⊔ 𝓟 (Ioo a b)"
] | [
" 𝓝ˢ (Ici a) = 𝓝 a ⊔ 𝓟 (Ioi a)"
] |
import Mathlib.Data.Num.Lemmas
import Mathlib.Data.Nat.Prime
import Mathlib.Tactic.Ring
#align_import data.num.prime from "leanprover-community/mathlib"@"58581d0fe523063f5651df0619be2bf65012a94a"
namespace PosNum
def minFacAux (n : PosNum) : ℕ → PosNum → PosNum
| 0, _ => n
| fuel + 1, k =>
if n < k.bit1... | Mathlib/Data/Num/Prime.lean | 65 | 83 | theorem minFac_to_nat (n : PosNum) : (minFac n : ℕ) = Nat.minFac n := by |
cases' n with n
· rfl
· rw [minFac, Nat.minFac_eq, if_neg]
swap
· simp
rw [minFacAux_to_nat]
· rfl
simp only [cast_one, cast_bit1]
unfold _root_.bit1 _root_.bit0
rw [Nat.sqrt_lt]
calc
(n : ℕ) + (n : ℕ) + 1 ≤ (n : ℕ) + (n : ℕ) + (n : ℕ) := by simp
_ = (n : ℕ) * (1 + 1 +... | [
" ↑(n.minFacAux fuel k) = (↑n).minFacAux ↑k.bit1",
" ↑(n.minFacAux 0 k) = (↑n).minFacAux ↑k.bit1",
" ↑(n.minFacAux (fuel + 1) k) = (↑n).minFacAux ↑k.bit1",
" ↑n = if ↑n < ↑k.bit1 * ↑k.bit1 then ↑n else if ↑k.bit1 ∣ ↑n then ↑k.bit1 else (↑n).minFacAux (↑k.bit1 + 2)",
" ↑(if n < k.bit1 * k.bit1 then n else if... | [
" ↑(n.minFacAux fuel k) = (↑n).minFacAux ↑k.bit1",
" ↑(n.minFacAux 0 k) = (↑n).minFacAux ↑k.bit1",
" ↑(n.minFacAux (fuel + 1) k) = (↑n).minFacAux ↑k.bit1",
" ↑n = if ↑n < ↑k.bit1 * ↑k.bit1 then ↑n else if ↑k.bit1 ∣ ↑n then ↑k.bit1 else (↑n).minFacAux (↑k.bit1 + 2)",
" ↑(if n < k.bit1 * k.bit1 then n else if... |
import Mathlib.CategoryTheory.Subobject.Lattice
#align_import category_theory.subobject.limits from "leanprover-community/mathlib"@"956af7c76589f444f2e1313911bad16366ea476d"
universe v u
noncomputable section
open CategoryTheory CategoryTheory.Category CategoryTheory.Limits CategoryTheory.Subobject Opposite
var... | Mathlib/CategoryTheory/Subobject/Limits.lean | 350 | 353 | theorem factorThruImageSubobject_comp_self_assoc {W W' : C} (k : W ⟶ W') (k' : W' ⟶ X) (h) :
(imageSubobject f).factorThru (k ≫ k' ≫ f) h = k ≫ k' ≫ factorThruImageSubobject f := by |
ext
simp
| [
" (imageSubobjectIso f).hom ≫ image.ι f = (imageSubobject f).arrow",
" (imageSubobjectIso f).inv ≫ (imageSubobject f).arrow = image.ι f",
" Epi (factorThruImageSubobject f)",
" Epi (factorThruImage f ≫ (imageSubobjectIso f).inv)",
" factorThruImageSubobject f ≫ (imageSubobject f).arrow = f",
" factorThruI... | [
" (imageSubobjectIso f).hom ≫ image.ι f = (imageSubobject f).arrow",
" (imageSubobjectIso f).inv ≫ (imageSubobject f).arrow = image.ι f",
" Epi (factorThruImageSubobject f)",
" Epi (factorThruImage f ≫ (imageSubobjectIso f).inv)",
" factorThruImageSubobject f ≫ (imageSubobject f).arrow = f",
" factorThruI... |
import Mathlib.Data.Fin.Tuple.Basic
import Mathlib.Data.List.Join
#align_import data.list.of_fn from "leanprover-community/mathlib"@"bf27744463e9620ca4e4ebe951fe83530ae6949b"
universe u
variable {α : Type u}
open Nat
namespace List
#noalign list.length_of_fn_aux
@[simp]
theorem length_ofFn_go {n} (f : Fin n ... | Mathlib/Data/List/OfFn.lean | 50 | 54 | theorem get_ofFn_go {n} (f : Fin n → α) (i j h) (k) (hk) :
get (ofFn.go f i j h) ⟨k, hk⟩ = f ⟨j + k, by simp at hk; omega⟩ := by |
let i+1 := i
cases k <;> simp [ofFn.go, get_ofFn_go (i := i)]
congr 2; omega
| [
" (ofFn.go f i j h).length = i",
" (ofFn.go f 0 j h).length = 0",
" (ofFn.go f (n✝ + 1) j h).length = n✝ + 1",
" (ofFn f).length = n",
" j + k < n",
" (ofFn.go f i j h).get ⟨k, hk⟩ = f ⟨j + k, ⋯⟩",
" (ofFn.go f (i + 1) j h).get ⟨k, hk⟩ = f ⟨j + k, ⋯⟩",
" (ofFn.go f (i + 1) j h).get ⟨0, hk⟩ = f ⟨j + 0,... | [
" (ofFn.go f i j h).length = i",
" (ofFn.go f 0 j h).length = 0",
" (ofFn.go f (n✝ + 1) j h).length = n✝ + 1",
" (ofFn f).length = n"
] |
import Mathlib.Probability.Kernel.Disintegration.Unique
import Mathlib.Probability.Notation
#align_import probability.kernel.cond_distrib from "leanprover-community/mathlib"@"00abe0695d8767201e6d008afa22393978bb324d"
open MeasureTheory Set Filter TopologicalSpace
open scoped ENNReal MeasureTheory ProbabilityTheo... | Mathlib/Probability/Kernel/CondDistrib.lean | 88 | 93 | theorem _root_.MeasureTheory.AEStronglyMeasurable.ae_integrable_condDistrib_map_iff
(hY : AEMeasurable Y μ) (hf : AEStronglyMeasurable f (μ.map fun a => (X a, Y a))) :
(∀ᵐ a ∂μ.map X, Integrable (fun ω => f (a, ω)) (condDistrib Y X μ a)) ∧
Integrable (fun a => ∫ ω, ‖f (a, ω)‖ ∂condDistrib Y X μ a) (μ.map ... |
rw [condDistrib, ← hf.ae_integrable_condKernel_iff, Measure.fst_map_prod_mk₀ hY]
| [
" IsMarkovKernel (condDistrib Y X μ)",
" IsMarkovKernel (Measure.map (fun a => (X a, Y a)) μ).condKernel",
" ((condDistrib Y X μ) x) s = ((Measure.map X μ) {x})⁻¹ * (Measure.map (fun a => (X a, Y a)) μ) ({x} ×ˢ s)",
" ((Measure.map (fun a => (X a, Y a)) μ).fst {x})⁻¹ * (Measure.map (fun a => (X a, Y a)) μ) ({... | [
" IsMarkovKernel (condDistrib Y X μ)",
" IsMarkovKernel (Measure.map (fun a => (X a, Y a)) μ).condKernel",
" ((condDistrib Y X μ) x) s = ((Measure.map X μ) {x})⁻¹ * (Measure.map (fun a => (X a, Y a)) μ) ({x} ×ˢ s)",
" ((Measure.map (fun a => (X a, Y a)) μ).fst {x})⁻¹ * (Measure.map (fun a => (X a, Y a)) μ) ({... |
import Mathlib.Topology.Category.TopCat.Limits.Products
#align_import topology.category.Top.limits.pullbacks from "leanprover-community/mathlib"@"178a32653e369dce2da68dc6b2694e385d484ef1"
-- Porting note: every ML3 decl has an uppercase letter
set_option linter.uppercaseLean3 false
open TopologicalSpace
open Cat... | Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean | 447 | 452 | theorem coinduced_of_isColimit {F : J ⥤ TopCat.{max v u}} (c : Cocone F) (hc : IsColimit c) :
c.pt.str = ⨆ j, (F.obj j).str.coinduced (c.ι.app j) := by |
let homeo := homeoOfIso (hc.coconePointUniqueUpToIso (colimitCoconeIsColimit F))
ext
refine homeo.symm.isOpen_preimage.symm.trans (Iff.trans ?_ isOpen_iSup_iff.symm)
exact isOpen_iSup_iff
| [
" c.pt.str = ⨆ j, coinduced (⇑(c.ι.app j)) (F.obj j).str",
" IsOpen x✝ ↔ IsOpen x✝",
" IsOpen (⇑homeo.symm ⁻¹' x✝) ↔ ∀ (i : J), IsOpen x✝"
] | [] |
import Mathlib.Analysis.Complex.Basic
import Mathlib.Analysis.SpecificLimits.Normed
open Filter Finset
open scoped Topology
namespace Complex
section StolzSet
open Real
def stolzSet (M : ℝ) : Set ℂ := {z | ‖z‖ < 1 ∧ ‖1 - z‖ < M * (1 - ‖z‖)}
def stolzCone (s : ℝ) : Set ℂ := {z | |z.im| < s * (1 - z.re)}
| Mathlib/Analysis/Complex/AbelLimit.lean | 47 | 54 | theorem stolzSet_empty {M : ℝ} (hM : M ≤ 1) : stolzSet M = ∅ := by |
ext z
rw [stolzSet, Set.mem_setOf, Set.mem_empty_iff_false, iff_false, not_and, not_lt, ← sub_pos]
intro zn
calc
_ ≤ 1 * (1 - ‖z‖) := mul_le_mul_of_nonneg_right hM zn.le
_ = ‖(1 : ℂ)‖ - ‖z‖ := by rw [one_mul, norm_one]
_ ≤ _ := norm_sub_norm_le _ _
| [
" stolzSet M = ∅",
" z ∈ stolzSet M ↔ z ∈ ∅",
" 0 < 1 - ‖z‖ → M * (1 - ‖z‖) ≤ ‖1 - z‖",
" M * (1 - ‖z‖) ≤ ‖1 - z‖",
" 1 * (1 - ‖z‖) = ‖1‖ - ‖z‖"
] | [] |
import Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure
import Mathlib.RingTheory.IntegralDomain
#align_import field_theory.primitive_element from "leanprover-community/mathlib"@"df76f43357840485b9d04ed5dee5ab115d420e87"
noncomputable section
open scoped Classical Polynomial
open FiniteDimensional Polynomial In... | Mathlib/FieldTheory/PrimitiveElement.lean | 56 | 67 | theorem exists_primitive_element_of_finite_top [Finite E] : ∃ α : E, F⟮α⟯ = ⊤ := by |
obtain ⟨α, hα⟩ := @IsCyclic.exists_generator Eˣ _ _
use α
rw [eq_top_iff]
rintro x -
by_cases hx : x = 0
· rw [hx]
exact F⟮α.val⟯.zero_mem
· obtain ⟨n, hn⟩ := Set.mem_range.mp (hα (Units.mk0 x hx))
simp only at hn
rw [show x = α ^ n by norm_cast; rw [hn, Units.val_mk0]]
exact zpow_mem (me... | [
" ∃ α, F⟮α⟯ = ⊤",
" F⟮↑α⟯ = ⊤",
" ⊤ ≤ F⟮↑α⟯",
" x ∈ F⟮↑α⟯",
" 0 ∈ F⟮↑α⟯",
" x = ↑α ^ n",
" x = ↑(α ^ n)",
" ↑α ^ n ∈ F⟮↑α⟯"
] | [] |
import Mathlib.Algebra.Order.Floor
import Mathlib.Topology.Algebra.Order.Group
import Mathlib.Topology.Order.Basic
#align_import topology.algebra.order.floor from "leanprover-community/mathlib"@"84dc0bd6619acaea625086d6f53cb35cdd554219"
open Filter Function Int Set Topology
variable {α β γ : Type*} [LinearOrdere... | Mathlib/Topology/Algebra/Order/Floor.lean | 108 | 110 | theorem tendsto_ceil_right_pure_add_one (n : ℤ) :
Tendsto (ceil : α → ℤ) (𝓝[>] n) (pure (n + 1)) := by |
simpa only [floor_intCast] using tendsto_ceil_right_pure_floor_add_one (n : α)
| [
" b ≤ ⌊↑(b + 1)⌋",
" b ≤ b + 1",
" ⌈↑(b - 1)⌉ ≤ b",
" b - 1 ≤ b",
" Tendsto floor (𝓝[≥] ↑n) (pure n)",
" Tendsto ceil (𝓝[≤] ↑n) (pure n)",
" ↑(⌈x⌉ - 1) < x",
" ↑⌈x⌉ < x + 1",
" x ≤ ↑(⌈x⌉ - 1) + 1",
" x ≤ ↑⌈x⌉",
" Tendsto floor (𝓝[<] ↑n) (pure (n - 1))",
" ↑(⌊x⌋ + 1) - 1 ≤ x",
" ↑⌊x⌋ ≤ x",... | [
" b ≤ ⌊↑(b + 1)⌋",
" b ≤ b + 1",
" ⌈↑(b - 1)⌉ ≤ b",
" b - 1 ≤ b",
" Tendsto floor (𝓝[≥] ↑n) (pure n)",
" Tendsto ceil (𝓝[≤] ↑n) (pure n)",
" ↑(⌈x⌉ - 1) < x",
" ↑⌈x⌉ < x + 1",
" x ≤ ↑(⌈x⌉ - 1) + 1",
" x ≤ ↑⌈x⌉",
" Tendsto floor (𝓝[<] ↑n) (pure (n - 1))",
" ↑(⌊x⌋ + 1) - 1 ≤ x",
" ↑⌊x⌋ ≤ x"
... |
import Mathlib.Order.Filter.Bases
#align_import order.filter.pi from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
open Set Function
open scoped Classical
open Filter
namespace Filter
variable {ι : Type*} {α : ι → Type*} {f f₁ f₂ : (i : ι) → Filter (α i)} {s : (i : ι) → Set (α i)}
... | Mathlib/Order/Filter/Pi.lean | 80 | 88 | theorem mem_pi {s : Set (∀ i, α i)} :
s ∈ pi f ↔ ∃ I : Set ι, I.Finite ∧ ∃ t : ∀ i, Set (α i), (∀ i, t i ∈ f i) ∧ I.pi t ⊆ s := by |
constructor
· simp only [pi, mem_iInf', mem_comap, pi_def]
rintro ⟨I, If, V, hVf, -, rfl, -⟩
choose t htf htV using hVf
exact ⟨I, If, t, htf, iInter₂_mono fun i _ => htV i⟩
· rintro ⟨I, If, t, htf, hts⟩
exact mem_of_superset (pi_mem_pi If fun i _ => htf i) hts
| [
" Tendsto m l (pi f) ↔ ∀ (i : ι), Tendsto (fun x => m x i) l (f i)",
" (∀ (i : ι), Tendsto (eval i ∘ m) l (f i)) ↔ ∀ (i : ι), Tendsto (fun x => m x i) l (f i)",
" I.pi s ∈ pi f",
" ⋂ x, eval ↑x ⁻¹' s ↑x ∈ pi f",
" eval ↑i ⁻¹' s ↑i ∈ comap (eval ↑i) (f ↑i)",
" s ∈ pi f ↔ ∃ I, I.Finite ∧ ∃ t, (∀ (i : ι), t ... | [
" Tendsto m l (pi f) ↔ ∀ (i : ι), Tendsto (fun x => m x i) l (f i)",
" (∀ (i : ι), Tendsto (eval i ∘ m) l (f i)) ↔ ∀ (i : ι), Tendsto (fun x => m x i) l (f i)",
" I.pi s ∈ pi f",
" ⋂ x, eval ↑x ⁻¹' s ↑x ∈ pi f",
" eval ↑i ⁻¹' s ↑i ∈ comap (eval ↑i) (f ↑i)"
] |
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Algebra.Order.Ring.Rat
import Mathlib.Data.Multiset.Sort
import Mathlib.Data.PNat.Basic
import Mathlib.Data.PNat.Interval
import Mathlib.Tactic.NormNum
import Mathlib.Tactic.IntervalCases
#align_import number_theory.ADE_inequality from "leanprover-community/math... | Mathlib/NumberTheory/ADEInequality.lean | 198 | 213 | theorem lt_four {q r : ℕ+} (hqr : q ≤ r) (H : 1 < sumInv {2, q, r}) : q < 4 := by |
have h4 : (0 : ℚ) < 4 := by norm_num
contrapose! H
rw [sumInv_pqr]
have h4r := H.trans hqr
have hq: (q : ℚ)⁻¹ ≤ 4⁻¹ := by
rw [inv_le_inv _ h4]
· assumption_mod_cast
· norm_num
have hr: (r : ℚ)⁻¹ ≤ 4⁻¹ := by
rw [inv_le_inv _ h4]
· assumption_mod_cast
· norm_num
calc
(2⁻¹ + (q :... | [
" sumInv {p, q, r} = (↑↑p)⁻¹ + (↑↑q)⁻¹ + (↑↑r)⁻¹",
" Admissible pqr → 1 < sumInv pqr",
" (∃ q r, A' q r = pqr) ∨ (∃ r, D' r = pqr) ∨ E' 3 = pqr ∨ E' 4 = pqr ∨ E' 5 = pqr → 1 < sumInv pqr",
" 1 < sumInv pqr",
" 1 < (↑↑1)⁻¹ + ((↑↑p')⁻¹ + (↑↑q')⁻¹)",
" 0 < (↑↑p')⁻¹ + (↑↑q')⁻¹",
" 0 < (↑↑p')⁻¹",
" 0 < (↑↑... | [
" sumInv {p, q, r} = (↑↑p)⁻¹ + (↑↑q)⁻¹ + (↑↑r)⁻¹",
" Admissible pqr → 1 < sumInv pqr",
" (∃ q r, A' q r = pqr) ∨ (∃ r, D' r = pqr) ∨ E' 3 = pqr ∨ E' 4 = pqr ∨ E' 5 = pqr → 1 < sumInv pqr",
" 1 < sumInv pqr",
" 1 < (↑↑1)⁻¹ + ((↑↑p')⁻¹ + (↑↑q')⁻¹)",
" 0 < (↑↑p')⁻¹ + (↑↑q')⁻¹",
" 0 < (↑↑p')⁻¹",
" 0 < (↑↑... |
import Mathlib.Order.Filter.CountableInter
set_option autoImplicit true
open Function Set Filter
class HasCountableSeparatingOn (α : Type*) (p : Set α → Prop) (t : Set α) : Prop where
exists_countable_separating : ∃ S : Set (Set α), S.Countable ∧ (∀ s ∈ S, p s) ∧
∀ x ∈ t, ∀ y ∈ t, (∀ s ∈ S, x ∈ s ↔ y ∈ s) ... | Mathlib/Order/Filter/CountableSeparatingOn.lean | 128 | 139 | theorem HasCountableSeparatingOn.subtype_iff {α : Type*} {p : Set α → Prop} {t : Set α} :
HasCountableSeparatingOn t (fun u ↦ ∃ v, p v ∧ (↑) ⁻¹' v = u) univ ↔
HasCountableSeparatingOn α p t := by |
constructor <;> intro h
· exact h.of_subtype $ fun s ↦ id
rcases h with ⟨S, Sct, Sp, hS⟩
use {Subtype.val ⁻¹' s | s ∈ S}, Sct.image _, ?_, ?_
· rintro u ⟨t, tS, rfl⟩
exact ⟨t, Sp _ tS, rfl⟩
rintro x - y - hxy
exact Subtype.val_injective $ hS _ (Subtype.coe_prop _) _ (Subtype.coe_prop _)
fun s hs ... | [
" ∃ S, (∀ (n : ℕ), p (S n)) ∧ ∀ x ∈ t, ∀ y ∈ t, (∀ (n : ℕ), x ∈ S n ↔ y ∈ S n) → x = y",
" (∀ (n : ℕ), p (S n)) ∧ ∀ x ∈ t, ∀ y ∈ t, (∀ (n : ℕ), x ∈ S n ↔ y ∈ S n) → x = y",
" HasCountableSeparatingOn α p t",
" x = y",
" ⟨x, hx⟩ ∈ U ↔ ⟨y, hy⟩ ∈ U",
" ⟨x, hx⟩ ∈ Subtype.val ⁻¹' V U ↔ ⟨y, hy⟩ ∈ Subtype.val ⁻¹... | [
" ∃ S, (∀ (n : ℕ), p (S n)) ∧ ∀ x ∈ t, ∀ y ∈ t, (∀ (n : ℕ), x ∈ S n ↔ y ∈ S n) → x = y",
" (∀ (n : ℕ), p (S n)) ∧ ∀ x ∈ t, ∀ y ∈ t, (∀ (n : ℕ), x ∈ S n ↔ y ∈ S n) → x = y",
" HasCountableSeparatingOn α p t",
" x = y",
" ⟨x, hx⟩ ∈ U ↔ ⟨y, hy⟩ ∈ U",
" ⟨x, hx⟩ ∈ Subtype.val ⁻¹' V U ↔ ⟨y, hy⟩ ∈ Subtype.val ⁻¹... |
import Mathlib.MeasureTheory.Function.L1Space
import Mathlib.MeasureTheory.Function.SimpleFuncDense
#align_import measure_theory.function.simple_func_dense_lp from "leanprover-community/mathlib"@"5a2df4cd59cb31e97a516d4603a14bed5c2f9425"
noncomputable section
set_option linter.uppercaseLean3 false
open Set Func... | Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean | 93 | 135 | theorem tendsto_approxOn_Lp_snorm [OpensMeasurableSpace E] {f : β → E} (hf : Measurable f)
{s : Set E} {y₀ : E} (h₀ : y₀ ∈ s) [SeparableSpace s] (hp_ne_top : p ≠ ∞) {μ : Measure β}
(hμ : ∀ᵐ x ∂μ, f x ∈ closure s) (hi : snorm (fun x => f x - y₀) p μ < ∞) :
Tendsto (fun n => snorm (⇑(approxOn f hf s y₀ h₀ n) ... |
by_cases hp_zero : p = 0
· simpa only [hp_zero, snorm_exponent_zero] using tendsto_const_nhds
have hp : 0 < p.toReal := toReal_pos hp_zero hp_ne_top
suffices
Tendsto (fun n => ∫⁻ x, (‖approxOn f hf s y₀ h₀ n x - f x‖₊ : ℝ≥0∞) ^ p.toReal ∂μ) atTop
(𝓝 0) by
simp only [snorm_eq_lintegral_rpow_n... | [
" ‖↑(approxOn f hf s y₀ h₀ n) x - f x‖₊ ≤ ‖f x - y₀‖₊",
" ‖↑(approxOn f hf s y₀ h₀ n) x - y₀‖ ≤ ‖f x - y₀‖ + ‖f x - y₀‖",
" ‖↑(approxOn f hf s 0 h₀ n) x‖ ≤ ‖f x‖ + ‖f x‖",
" Tendsto (fun n => snorm (↑(approxOn f hf s y₀ h₀ n) - f) p μ) atTop (𝓝 0)",
" Tendsto (fun n => (∫⁻ (x : β), ↑‖(↑(approxOn f hf s y₀ ... | [
" ‖↑(approxOn f hf s y₀ h₀ n) x - f x‖₊ ≤ ‖f x - y₀‖₊",
" ‖↑(approxOn f hf s y₀ h₀ n) x - y₀‖ ≤ ‖f x - y₀‖ + ‖f x - y₀‖",
" ‖↑(approxOn f hf s 0 h₀ n) x‖ ≤ ‖f x‖ + ‖f x‖"
] |
import Mathlib.AlgebraicGeometry.AffineScheme
import Mathlib.AlgebraicGeometry.Pullbacks
import Mathlib.CategoryTheory.MorphismProperty.Limits
import Mathlib.Data.List.TFAE
#align_import algebraic_geometry.morphisms.basic from "leanprover-community/mathlib"@"434e2fd21c1900747afc6d13d8be7f4eedba7218"
set_option lin... | Mathlib/AlgebraicGeometry/Morphisms/Basic.lean | 109 | 116 | theorem AffineTargetMorphismProperty.respectsIso_mk {P : AffineTargetMorphismProperty}
(h₁ : ∀ {X Y Z} (e : X ≅ Y) (f : Y ⟶ Z) [IsAffine Z], P f → P (e.hom ≫ f))
(h₂ : ∀ {X Y Z} (e : Y ≅ Z) (f : X ⟶ Y) [h : IsAffine Y],
P f → @P _ _ (f ≫ e.hom) (isAffineOfIso e.inv)) :
P.toProperty.RespectsIso := by |
constructor
· rintro X Y Z e f ⟨a, h⟩; exact ⟨a, h₁ e f h⟩
· rintro X Y Z e f ⟨a, h⟩; exact ⟨isAffineOfIso e.inv, h₂ e f h⟩
| [
" P.toProperty f ↔ P f",
" (∃ (h : IsAffine Y), P f) ↔ P f",
" P (f ≫ g) ↔ P g",
" P (f ≫ g) ↔ P f",
" P.toProperty.RespectsIso",
" ∀ {X Y Z : Scheme} (e : X ≅ Y) (f : Y ⟶ Z), P.toProperty f → P.toProperty (e.hom ≫ f)",
" P.toProperty (e.hom ≫ f)",
" ∀ {X Y Z : Scheme} (e : Y ≅ Z) (f : X ⟶ Y), P.toPro... | [
" P.toProperty f ↔ P f",
" (∃ (h : IsAffine Y), P f) ↔ P f",
" P (f ≫ g) ↔ P g",
" P (f ≫ g) ↔ P f"
] |
import Mathlib.Analysis.Complex.Circle
import Mathlib.LinearAlgebra.Determinant
import Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup
#align_import analysis.complex.isometry from "leanprover-community/mathlib"@"ae690b0c236e488a0043f6faa8ce3546e7f2f9c5"
noncomputable section
open Complex
open ComplexConjugate
... | Mathlib/Analysis/Complex/Isometry.lean | 96 | 101 | theorem LinearIsometry.im_apply_eq_im_or_neg_of_re_apply_eq_re {f : ℂ →ₗᵢ[ℝ] ℂ}
(h₂ : ∀ z, (f z).re = z.re) (z : ℂ) : (f z).im = z.im ∨ (f z).im = -z.im := by |
have h₁ := f.norm_map z
simp only [Complex.abs_def, norm_eq_abs] at h₁
rwa [Real.sqrt_inj (normSq_nonneg _) (normSq_nonneg _), normSq_apply (f z), normSq_apply z,
h₂, add_left_cancel_iff, mul_self_eq_mul_self_iff] at h₁
| [
" Complex.abs (↑a * x) = Complex.abs x",
" (rotation a).trans (rotation b) = rotation (b * a)",
" ((rotation a).trans (rotation b)) x✝ = (rotation (b * a)) x✝",
" rotation a ≠ conjLIE",
" False",
" e 1 / ↑(Complex.abs (e 1)) ∈ circle",
" ↑(rotationOf (rotation a)) = ↑a",
" (f z).re = z.re",
" 2 ≠ 0"... | [
" Complex.abs (↑a * x) = Complex.abs x",
" (rotation a).trans (rotation b) = rotation (b * a)",
" ((rotation a).trans (rotation b)) x✝ = (rotation (b * a)) x✝",
" rotation a ≠ conjLIE",
" False",
" e 1 / ↑(Complex.abs (e 1)) ∈ circle",
" ↑(rotationOf (rotation a)) = ↑a",
" (f z).re = z.re",
" 2 ≠ 0"... |
import Batteries.Data.List.Basic
import Batteries.Data.List.Lemmas
open Nat
namespace List
section countP
variable (p q : α → Bool)
@[simp] theorem countP_nil : countP p [] = 0 := rfl
protected theorem countP_go_eq_add (l) : countP.go p l n = n + countP.go p l 0 := by
induction l generalizing n with
| nil... | .lake/packages/batteries/Batteries/Data/List/Count.lean | 68 | 70 | theorem countP_le_length : countP p l ≤ l.length := by |
simp only [countP_eq_length_filter]
apply length_filter_le
| [
" countP.go p l n = n + countP.go p l 0",
" countP.go p [] n = n + countP.go p [] 0",
" countP.go p (head :: tail) n = n + countP.go p (head :: tail) 0",
" (bif p head then countP.go p tail (n + 1) else countP.go p tail n) =\n n + bif p head then countP.go p tail (0 + 1) else countP.go p tail 0",
" (bif ... | [
" countP.go p l n = n + countP.go p l 0",
" countP.go p [] n = n + countP.go p [] 0",
" countP.go p (head :: tail) n = n + countP.go p (head :: tail) 0",
" (bif p head then countP.go p tail (n + 1) else countP.go p tail n) =\n n + bif p head then countP.go p tail (0 + 1) else countP.go p tail 0",
" (bif ... |
namespace Nat
@[reducible] def Coprime (m n : Nat) : Prop := gcd m n = 1
instance (m n : Nat) : Decidable (Coprime m n) := inferInstanceAs (Decidable (_ = 1))
theorem coprime_iff_gcd_eq_one : Coprime m n ↔ gcd m n = 1 := .rfl
theorem Coprime.gcd_eq_one : Coprime m n → gcd m n = 1 := id
theorem Coprime.symm ... | .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean | 32 | 34 | theorem Coprime.dvd_of_dvd_mul_right (H1 : Coprime k n) (H2 : k ∣ m * n) : k ∣ m := by |
let t := dvd_gcd (Nat.dvd_mul_left k m) H2
rwa [gcd_mul_left, H1.gcd_eq_one, Nat.mul_one] at t
| [
" k ∣ m"
] | [] |
import Mathlib.CategoryTheory.Galois.GaloisObjects
import Mathlib.CategoryTheory.Limits.Shapes.CombinedProducts
universe u₁ u₂ w
namespace CategoryTheory
open Limits Functor
variable {C : Type u₁} [Category.{u₂} C]
namespace PreGaloisCategory
variable [GaloisCategory C]
section Decomposition
private lemma... | Mathlib/CategoryTheory/Galois/Decomposition.lean | 111 | 115 | theorem has_decomp_connected_components (X : C) :
∃ (ι : Type) (f : ι → C) (g : (i : ι) → f i ⟶ X) (_ : IsColimit (Cofan.mk X g)),
(∀ i, IsConnected (f i)) ∧ Finite ι := by |
let F := GaloisCategory.getFiberFunctor C
exact has_decomp_connected_components_aux F (Nat.card <| F.obj X) X rfl
| [
" ∃ ι f g x, (∀ (i : ι), IsConnected (f i)) ∧ Finite ι",
" (∀ (i : Unit), IsConnected ((fun x => X) i)) ∧ Finite Unit",
" ∃ x, (∀ (i : Empty), IsConnected ((fun x => X) i)) ∧ Finite Empty",
" ∀ (j : Empty), (Cofan.mk X fun x => 𝟙 X).inj j ≫ (fun s => h.to s.pt) s = s.inj j",
" (∀ (i : Empty), IsConnected (... | [
" ∃ ι f g x, (∀ (i : ι), IsConnected (f i)) ∧ Finite ι",
" (∀ (i : Unit), IsConnected ((fun x => X) i)) ∧ Finite Unit",
" ∃ x, (∀ (i : Empty), IsConnected ((fun x => X) i)) ∧ Finite Empty",
" ∀ (j : Empty), (Cofan.mk X fun x => 𝟙 X).inj j ≫ (fun s => h.to s.pt) s = s.inj j",
" (∀ (i : Empty), IsConnected (... |
import Mathlib.Algebra.Group.Semiconj.Defs
import Mathlib.Algebra.Ring.Defs
#align_import algebra.ring.semiconj from "leanprover-community/mathlib"@"70d50ecfd4900dd6d328da39ab7ebd516abe4025"
universe u v w x
variable {α : Type u} {β : Type v} {γ : Type w} {R : Type x}
open Function
namespace SemiconjBy
@[simp... | Mathlib/Algebra/Ring/Semiconj.lean | 33 | 35 | theorem add_right [Distrib R] {a x y x' y' : R} (h : SemiconjBy a x y) (h' : SemiconjBy a x' y') :
SemiconjBy a (x + x') (y + y') := by |
simp only [SemiconjBy, left_distrib, right_distrib, h.eq, h'.eq]
| [
" SemiconjBy a (x + x') (y + y')"
] | [] |
import Mathlib.Algebra.Group.Units
import Mathlib.Algebra.GroupWithZero.Basic
import Mathlib.Logic.Equiv.Defs
import Mathlib.Tactic.Contrapose
import Mathlib.Tactic.Nontriviality
import Mathlib.Tactic.Spread
import Mathlib.Util.AssertExists
#align_import algebra.group_with_zero.units.basic from "leanprover-community/... | Mathlib/Algebra/GroupWithZero/Units/Basic.lean | 108 | 110 | theorem mul_inverse_cancel (x : M₀) (h : IsUnit x) : x * inverse x = 1 := by |
rcases h with ⟨u, rfl⟩
rw [inverse_unit, Units.mul_inv]
| [
" 0 = 1",
" inverse ↑u = ↑u⁻¹",
" x * inverse x = 1",
" ↑u * inverse ↑u = 1"
] | [
" 0 = 1",
" inverse ↑u = ↑u⁻¹"
] |
import Mathlib.Algebra.IsPrimePow
import Mathlib.SetTheory.Cardinal.Ordinal
import Mathlib.Tactic.WLOG
#align_import set_theory.cardinal.divisibility from "leanprover-community/mathlib"@"ea050b44c0f9aba9d16a948c7cc7d2e7c8493567"
namespace Cardinal
open Cardinal
universe u
variable {a b : Cardinal.{u}} {n m : ℕ... | Mathlib/SetTheory/Cardinal/Divisibility.lean | 137 | 141 | theorem is_prime_iff {a : Cardinal} : Prime a ↔ ℵ₀ ≤ a ∨ ∃ p : ℕ, a = p ∧ p.Prime := by |
rcases le_or_lt ℵ₀ a with h | h
· simp [h]
lift a to ℕ using id h
simp [not_le.mpr h]
| [
" IsUnit a ↔ a = 1",
" a = 1 → IsUnit a",
" IsUnit 1",
" a = 1",
" 0 = 1",
" 1 ≤ a",
" 1 ≤ t",
" t ≠ 0",
" False",
" a ≤ x",
" x = 0",
" Prime a",
" ¬IsUnit a",
" ¬a = 1",
" a ∣ b ∨ a ∣ c",
" a ∣ 0 ∨ a ∣ c",
" a ∣ b ∨ a ∣ 0",
" a ∣ c ∨ a ∣ b",
" b ≤ c",
" c * b ≠ 0",
" a ∣ c ... | [
" IsUnit a ↔ a = 1",
" a = 1 → IsUnit a",
" IsUnit 1",
" a = 1",
" 0 = 1",
" 1 ≤ a",
" 1 ≤ t",
" t ≠ 0",
" False",
" a ≤ x",
" x = 0",
" Prime a",
" ¬IsUnit a",
" ¬a = 1",
" a ∣ b ∨ a ∣ c",
" a ∣ 0 ∨ a ∣ c",
" a ∣ b ∨ a ∣ 0",
" a ∣ c ∨ a ∣ b",
" b ≤ c",
" c * b ≠ 0",
" a ∣ c ... |
import Mathlib.Logic.Encodable.Basic
import Mathlib.Logic.Pairwise
import Mathlib.Data.Set.Subsingleton
#align_import logic.encodable.lattice from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
open Set
namespace Encodable
variable {α : Type*} {β : Type*} [Encodable β]
theorem iSup_de... | Mathlib/Logic/Encodable/Lattice.lean | 53 | 59 | theorem iUnion_decode₂_disjoint_on {f : β → Set α} (hd : Pairwise (Disjoint on f)) :
Pairwise (Disjoint on fun i => ⋃ b ∈ decode₂ β i, f b) := by |
rintro i j ij
refine disjoint_left.mpr fun x => ?_
suffices ∀ a, encode a = i → x ∈ f a → ∀ b, encode b = j → x ∉ f b by simpa [decode₂_eq_some]
rintro a rfl ha b rfl hb
exact (hd (mt (congr_arg encode) ij)).le_bot ⟨ha, hb⟩
| [
" ⨆ i, ⨆ b ∈ decode₂ β i, f b = ⨆ b, f b",
" ⨆ j, ⨆ i, ⨆ (_ : j ∈ decode₂ β i), f j = ⨆ b, f b",
" C (⋃ b ∈ none, f b)",
" C ∅",
" C (⋃ b_1 ∈ some b, f b_1)",
" ⋃ b_1 ∈ some b, f b_1 = f b",
" Pairwise (Disjoint on fun i => ⋃ b ∈ decode₂ β i, f b)",
" (Disjoint on fun i => ⋃ b ∈ decode₂ β i, f b) i j"... | [
" ⨆ i, ⨆ b ∈ decode₂ β i, f b = ⨆ b, f b",
" ⨆ j, ⨆ i, ⨆ (_ : j ∈ decode₂ β i), f j = ⨆ b, f b",
" C (⋃ b ∈ none, f b)",
" C ∅",
" C (⋃ b_1 ∈ some b, f b_1)",
" ⋃ b_1 ∈ some b, f b_1 = f b"
] |
import Mathlib.RingTheory.FractionalIdeal.Basic
import Mathlib.RingTheory.Ideal.Norm
namespace FractionalIdeal
open scoped Pointwise nonZeroDivisors
variable {R : Type*} [CommRing R] [IsDedekindDomain R] [Module.Free ℤ R] [Module.Finite ℤ R]
variable {K : Type*} [CommRing K] [Algebra R K] [IsFractionRing R K]
| Mathlib/RingTheory/FractionalIdeal/Norm.lean | 36 | 51 | theorem absNorm_div_norm_eq_absNorm_div_norm {I : FractionalIdeal R⁰ K} (a : R⁰) (I₀ : Ideal R)
(h : a • (I : Submodule R K) = Submodule.map (Algebra.linearMap R K) I₀) :
(Ideal.absNorm I.num : ℚ) / |Algebra.norm ℤ (I.den:R)| =
(Ideal.absNorm I₀ : ℚ) / |Algebra.norm ℤ (a:R)| := by |
rw [div_eq_div_iff]
· replace h := congr_arg (I.den • ·) h
have h' := congr_arg (a • ·) (den_mul_self_eq_num I)
dsimp only at h h'
rw [smul_comm] at h
rw [h, Submonoid.smul_def, Submonoid.smul_def, ← Submodule.ideal_span_singleton_smul,
← Submodule.ideal_span_singleton_smul, ← Submodule.map_s... | [
" ↑(Ideal.absNorm I.num) / ↑|(Algebra.norm ℤ) ↑I.den| = ↑(Ideal.absNorm I₀) / ↑|(Algebra.norm ℤ) ↑a|",
" ↑(Ideal.absNorm I.num) * ↑|(Algebra.norm ℤ) ↑a| = ↑(Ideal.absNorm I₀) * ↑|(Algebra.norm ℤ) ↑I.den|",
" ↑(Ideal.absNorm I.num * Ideal.absNorm (Ideal.span {↑a})) = ↑(Ideal.absNorm I₀ * Ideal.absNorm (Ideal.spa... | [] |
import Mathlib.Data.Set.Pairwise.Basic
import Mathlib.Data.Set.Lattice
import Mathlib.Data.SetLike.Basic
#align_import order.chain from "leanprover-community/mathlib"@"c227d107bbada5d0d9d20287e3282c0a7f1651a0"
open scoped Classical
open Set
variable {α β : Type*}
section Chain
variable (r : α → α → Prop)
... | Mathlib/Order/Chain.lean | 184 | 188 | theorem IsChain.superChain_succChain (hs₁ : IsChain r s) (hs₂ : ¬IsMaxChain r s) :
SuperChain r s (SuccChain r s) := by |
simp only [IsMaxChain, _root_.not_and, not_forall, exists_prop, exists_and_left] at hs₂
obtain ⟨t, ht, hst⟩ := hs₂ hs₁
exact succChain_spec ⟨t, hs₁, ht, ssubset_iff_subset_ne.2 hst⟩
| [
" IsChain r univ ↔ IsTrichotomous α r",
" r a b ∨ a = b ∨ r b a",
" ¬a = b → r a b ∨ r b a",
" IsChain (fun x x_1 => x ≤ x_1) (range f)",
" IsChain (fun x x_1 => x ≤ x_1) (f '' univ)",
" SuperChain r s (SuccChain r s)",
" IsChain r (SuccChain r s)"
] | [
" IsChain r univ ↔ IsTrichotomous α r",
" r a b ∨ a = b ∨ r b a",
" ¬a = b → r a b ∨ r b a",
" IsChain (fun x x_1 => x ≤ x_1) (range f)",
" IsChain (fun x x_1 => x ≤ x_1) (f '' univ)",
" SuperChain r s (SuccChain r s)",
" IsChain r (SuccChain r s)"
] |
import Mathlib.LinearAlgebra.Dual
import Mathlib.LinearAlgebra.Matrix.ToLin
#align_import linear_algebra.contraction from "leanprover-community/mathlib"@"657df4339ae6ceada048c8a2980fb10e393143ec"
suppress_compilation
-- Porting note: universe metavariables behave oddly
universe w u v₁ v₂ v₃ v₄
variable {ι : Type... | Mathlib/LinearAlgebra/Contraction.lean | 133 | 140 | theorem toMatrix_dualTensorHom {m : Type*} {n : Type*} [Fintype m] [Finite n] [DecidableEq m]
[DecidableEq n] (bM : Basis m R M) (bN : Basis n R N) (j : m) (i : n) :
toMatrix bM bN (dualTensorHom R M N (bM.coord j ⊗ₜ bN i)) = stdBasisMatrix i j 1 := by |
ext i' j'
by_cases hij : i = i' ∧ j = j' <;>
simp [LinearMap.toMatrix_apply, Finsupp.single_eq_pi_single, hij]
rw [and_iff_not_or_not, Classical.not_not] at hij
cases' hij with hij hij <;> simp [hij]
| [
" Dual.transpose ((dualTensorHom R M M) (f ⊗ₜ[R] m)) =\n (dualTensorHom R (Dual R M) (Dual R M)) ((Dual.eval R M) m ⊗ₜ[R] f)",
" ((Dual.transpose ((dualTensorHom R M M) (f ⊗ₜ[R] m))) f') m' =\n (((dualTensorHom R (Dual R M) (Dual R M)) ((Dual.eval R M) m ⊗ₜ[R] f)) f') m'",
" f m' * f' m = f' m * f m'",
... | [
" Dual.transpose ((dualTensorHom R M M) (f ⊗ₜ[R] m)) =\n (dualTensorHom R (Dual R M) (Dual R M)) ((Dual.eval R M) m ⊗ₜ[R] f)",
" ((Dual.transpose ((dualTensorHom R M M) (f ⊗ₜ[R] m))) f') m' =\n (((dualTensorHom R (Dual R M) (Dual R M)) ((Dual.eval R M) m ⊗ₜ[R] f)) f') m'",
" f m' * f' m = f' m * f m'",
... |
import Mathlib.Data.Set.Subsingleton
import Mathlib.Order.WithBot
#align_import data.set.image from "leanprover-community/mathlib"@"001ffdc42920050657fd45bd2b8bfbec8eaaeb29"
universe u v
open Function Set
namespace Set
variable {α β γ : Type*} {ι ι' : Sort*}
section Preimage
variable {f : α → β} {g : β → γ... | Mathlib/Data/Set/Image.lean | 53 | 55 | theorem preimage_congr {f g : α → β} {s : Set β} (h : ∀ x : α, f x = g x) : f ⁻¹' s = g ⁻¹' s := by |
congr with x
simp [h]
| [
" f ⁻¹' s = g ⁻¹' s",
" x ∈ f ⁻¹' s ↔ x ∈ g ⁻¹' s"
] | [] |
import Mathlib.Algebra.Star.Basic
import Mathlib.Data.Set.Finite
import Mathlib.Data.Set.Pointwise.Basic
#align_import algebra.star.pointwise from "leanprover-community/mathlib"@"30413fc89f202a090a54d78e540963ed3de0056e"
namespace Set
open Pointwise
local postfix:max "⋆" => star
variable {α : Type*} {s t : Set... | Mathlib/Algebra/Star/Pointwise.lean | 107 | 108 | theorem star_subset [InvolutiveStar α] {s t : Set α} : s⋆ ⊆ t ↔ s ⊆ t⋆ := by |
rw [← star_subset_star, star_star]
| [
" a⋆ ∈ s⋆ ↔ a ∈ s",
" star '' s = s⋆",
" star '' s = star ⁻¹' s",
" Function.LeftInverse star star",
" Function.RightInverse star star",
" x✝⋆⋆ = x✝",
" s⋆⋆ = s",
" s⋆ ⊆ t ↔ s ⊆ t⋆"
] | [
" a⋆ ∈ s⋆ ↔ a ∈ s",
" star '' s = s⋆",
" star '' s = star ⁻¹' s",
" Function.LeftInverse star star",
" Function.RightInverse star star",
" x✝⋆⋆ = x✝",
" s⋆⋆ = s"
] |
import Mathlib.Analysis.NormedSpace.Exponential
import Mathlib.Analysis.NormedSpace.ProdLp
import Mathlib.Topology.Instances.TrivSqZeroExt
#align_import analysis.normed_space.triv_sq_zero_ext from "leanprover-community/mathlib"@"88a563b158f59f2983cfad685664da95502e8cdd"
variable (𝕜 : Type*) {S R M : Type*}
loca... | Mathlib/Analysis/NormedSpace/TrivSqZeroExt.lean | 83 | 88 | theorem snd_expSeries_of_smul_comm
(x : tsze R M) (hx : MulOpposite.op x.fst • x.snd = x.fst • x.snd) (n : ℕ) :
snd (expSeries 𝕜 (tsze R M) (n + 1) fun _ => x) = (expSeries 𝕜 R n fun _ => x.fst) • x.snd := by |
simp_rw [expSeries_apply_eq, snd_smul, snd_pow_of_smul_comm _ _ hx, nsmul_eq_smul_cast 𝕜 (n + 1),
smul_smul, smul_assoc, Nat.factorial_succ, Nat.pred_succ, Nat.cast_mul, mul_inv_rev,
inv_mul_cancel_right₀ ((Nat.cast_ne_zero (R := 𝕜)).mpr <| Nat.succ_ne_zero n)]
| [
" ((expSeries 𝕜 (tsze R M) (n + 1)) fun x_1 => x).snd = ((expSeries 𝕜 R n) fun x_1 => x.fst) • x.snd"
] | [] |
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.Data.Fintype.Basic
import Mathlib.Data.List.Sublists
import Mathlib.Data.List.InsertNth
#align_import group_theory.free_group from "leanprover-community/mathlib"@"f93c11933efbc3c2f0299e47b8ff83e9b539cbf6"
open Relation
universe u v w
variable {α : Type u... | Mathlib/GroupTheory/FreeGroup/Basic.lean | 160 | 173 | theorem Step.cons_left_iff {a : α} {b : Bool} :
Step ((a, b) :: L₁) L₂ ↔ (∃ L, Step L₁ L ∧ L₂ = (a, b) :: L) ∨ L₁ = (a, ! b) :: L₂ := by |
constructor
· generalize hL : ((a, b) :: L₁ : List _) = L
rintro @⟨_ | ⟨p, s'⟩, e, a', b'⟩
· simp at hL
simp [*]
· simp at hL
rcases hL with ⟨rfl, rfl⟩
refine Or.inl ⟨s' ++ e, Step.not, ?_⟩
simp
· rintro (⟨L, h, rfl⟩ | rfl)
· exact Step.cons h
· exact Step.cons_not
| [
" (L1 ++ L2).length + 2 = (L1 ++ (x, b) :: (x, !b) :: L2).length",
" L1.length + L2.length + 2 = L1.length + ((x, b) :: (x, !b) :: L2).length",
" Step (L₁ ++ (x, !b) :: (x, b) :: L₂) (L₁ ++ L₂)",
" Step (L₁ ++ (x, !false) :: (x, false) :: L₂) (L₁ ++ L₂)",
" Step (L₁ ++ (x, !true) :: (x, true) :: L₂) (L₁ ++ ... | [
" (L1 ++ L2).length + 2 = (L1 ++ (x, b) :: (x, !b) :: L2).length",
" L1.length + L2.length + 2 = L1.length + ((x, b) :: (x, !b) :: L2).length",
" Step (L₁ ++ (x, !b) :: (x, b) :: L₂) (L₁ ++ L₂)",
" Step (L₁ ++ (x, !false) :: (x, false) :: L₂) (L₁ ++ L₂)",
" Step (L₁ ++ (x, !true) :: (x, true) :: L₂) (L₁ ++ ... |
import Mathlib.RingTheory.Flat.Basic
import Mathlib.LinearAlgebra.TensorProduct.Vanishing
import Mathlib.Algebra.Module.FinitePresentation
universe u
variable {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M]
open Classical DirectSum LinearMap TensorProduct Finsupp
open scoped BigOperators
namespace Modu... | Mathlib/RingTheory/Flat/EquationalCriterion.lean | 81 | 83 | theorem isTrivialRelation_iff_vanishesTrivially :
IsTrivialRelation f x ↔ VanishesTrivially R f x := by |
simp only [IsTrivialRelation, VanishesTrivially, smul_eq_mul, mul_comm]
| [
" IsTrivialRelation f x ↔ VanishesTrivially R f x"
] | [] |
import Mathlib.Geometry.Manifold.ContMDiff.Defs
open Set Filter Function
open scoped Topology Manifold
variable {𝕜 : Type*} [NontriviallyNormedField 𝕜]
-- declare a smooth manifold `M` over the pair `(E, H)`.
{E : Type*}
[NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H]
(I : Mode... | Mathlib/Geometry/Manifold/ContMDiff/Basic.lean | 244 | 248 | theorem contMDiff_const : ContMDiff I I' n fun _ : M => c := by |
intro x
refine ⟨continuousWithinAt_const, ?_⟩
simp only [ContDiffWithinAtProp, (· ∘ ·)]
exact contDiffWithinAt_const
| [
" ContMDiff I I' n fun x => c",
" ContMDiffAt I I' n (fun x => c) x",
" ContDiffWithinAtProp I I' n (↑(chartAt H' c) ∘ (fun x => c) ∘ ↑(chartAt H x).symm) (↑(chartAt H x).symm ⁻¹' univ)\n (↑(chartAt H x) x)",
" ContDiffWithinAt 𝕜 n (fun x => ↑I' (↑(chartAt H' c) c)) (↑I.symm ⁻¹' (↑(chartAt H x).symm ⁻¹' u... | [] |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.RingTheory.Polynomial.Bernstein
import Mathlib.Topology.ContinuousFunction.Polynomial
import Mathlib.Topology.ContinuousFunction.Compact
#align_import analysis.special_functions.bernstein from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba14... | Mathlib/Analysis/SpecialFunctions/Bernstein.lean | 117 | 136 | theorem variance {n : ℕ} (h : 0 < (n : ℝ)) (x : I) :
(∑ k : Fin (n + 1), (x - k/ₙ : ℝ) ^ 2 * bernstein n k x) = (x : ℝ) * (1 - x) / n := by |
have h' : (n : ℝ) ≠ 0 := ne_of_gt h
apply_fun fun x : ℝ => x * n using GroupWithZero.mul_right_injective h'
apply_fun fun x : ℝ => x * n using GroupWithZero.mul_right_injective h'
dsimp
conv_lhs => simp only [Finset.sum_mul, z]
conv_rhs => rw [div_mul_cancel₀ _ h']
have := bernsteinPolynomial.variance ℝ ... | [
" (bernstein n ν) x = ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)",
" Polynomial.eval (↑x) (↑(n.choose ν) * Polynomial.X ^ ν * (1 - Polynomial.X) ^ (n - ν)) =\n ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)",
" 0 ≤ (bernstein n ν) x",
" 0 ≤ ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)",
" 0 ≤ ↑x",
" 0 ≤ 1... | [
" (bernstein n ν) x = ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)",
" Polynomial.eval (↑x) (↑(n.choose ν) * Polynomial.X ^ ν * (1 - Polynomial.X) ^ (n - ν)) =\n ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)",
" 0 ≤ (bernstein n ν) x",
" 0 ≤ ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)",
" 0 ≤ ↑x",
" 0 ≤ 1... |
import Mathlib.Data.Fintype.Option
import Mathlib.Data.Fintype.Prod
import Mathlib.Data.Fintype.Pi
import Mathlib.Data.Vector.Basic
import Mathlib.Data.PFun
import Mathlib.Logic.Function.Iterate
import Mathlib.Order.Basic
import Mathlib.Tactic.ApplyFun
#align_import computability.turing_machine from "leanprover-commu... | Mathlib/Computability/TuringMachine.lean | 85 | 88 | theorem BlankExtends.trans {Γ} [Inhabited Γ] {l₁ l₂ l₃ : List Γ} :
BlankExtends l₁ l₂ → BlankExtends l₂ l₃ → BlankExtends l₁ l₃ := by |
rintro ⟨i, rfl⟩ ⟨j, rfl⟩
exact ⟨i + j, by simp [List.replicate_add]⟩
| [
" l = l ++ List.replicate 0 default",
" BlankExtends l₁ l₂ → BlankExtends l₂ l₃ → BlankExtends l₁ l₃",
" BlankExtends l₁ (l₁ ++ List.replicate i default ++ List.replicate j default)",
" l₁ ++ List.replicate i default ++ List.replicate j default = l₁ ++ List.replicate (i + j) default"
] | [
" l = l ++ List.replicate 0 default"
] |
import Mathlib.GroupTheory.QuotientGroup
import Mathlib.LinearAlgebra.Span
#align_import linear_algebra.quotient from "leanprover-community/mathlib"@"48085f140e684306f9e7da907cd5932056d1aded"
-- For most of this file we work over a noncommutative ring
section Ring
namespace Submodule
variable {R M : Type*} {r : ... | Mathlib/LinearAlgebra/Quotient.lean | 100 | 100 | theorem mk_eq_zero : (mk x : M ⧸ p) = 0 ↔ x ∈ p := by | simpa using (Quotient.eq' p : mk x = 0 ↔ _)
| [
" Setoid.r x y ↔ -(x - y) ∈ p",
" -x + y ∈ p.toAddSubgroup ↔ -x + y ∈ p",
" mk x = 0 ↔ x ∈ p"
] | [
" Setoid.r x y ↔ -(x - y) ∈ p",
" -x + y ∈ p.toAddSubgroup ↔ -x + y ∈ p"
] |
import Mathlib.Algebra.ContinuedFractions.Basic
import Mathlib.Algebra.GroupWithZero.Basic
#align_import algebra.continued_fractions.translations from "leanprover-community/mathlib"@"a7e36e48519ab281320c4d192da6a7b348ce40ad"
namespace GeneralizedContinuedFraction
section General
variable {α : Type*} {g : Gen... | Mathlib/Algebra/ContinuedFractions/Translations.lean | 66 | 68 | theorem exists_s_a_of_part_num {a : α} (nth_part_num_eq : g.partialNumerators.get? n = some a) :
∃ gp, g.s.get? n = some gp ∧ gp.a = a := by |
simpa [partialNumerators, Stream'.Seq.map_get?] using nth_part_num_eq
| [
" g.TerminatedAt n ↔ g.s.TerminatedAt n",
" g.TerminatedAt n ↔ g.s.get? n = none",
" g.partialNumerators.get? n = none ↔ g.s.get? n = none",
" g.partialNumerators.get? n = none ↔ none = none",
" g.partialNumerators.get? n = none ↔ some val✝ = none",
" g.TerminatedAt n ↔ g.partialNumerators.get? n = none",... | [
" g.TerminatedAt n ↔ g.s.TerminatedAt n",
" g.TerminatedAt n ↔ g.s.get? n = none",
" g.partialNumerators.get? n = none ↔ g.s.get? n = none",
" g.partialNumerators.get? n = none ↔ none = none",
" g.partialNumerators.get? n = none ↔ some val✝ = none",
" g.TerminatedAt n ↔ g.partialNumerators.get? n = none",... |
import Mathlib.Order.Filter.EventuallyConst
import Mathlib.Order.PartialSups
import Mathlib.Algebra.Module.Submodule.IterateMapComap
import Mathlib.RingTheory.OrzechProperty
import Mathlib.RingTheory.Nilpotent.Lemmas
#align_import ring_theory.noetherian from "leanprover-community/mathlib"@"210657c4ea4a4a7b234392f70a3... | Mathlib/RingTheory/Noetherian.lean | 136 | 139 | theorem isNoetherian_top_iff : IsNoetherian R (⊤ : Submodule R M) ↔ IsNoetherian R M := by |
constructor <;> intro h
· exact isNoetherian_of_linearEquiv (LinearEquiv.ofTop (⊤ : Submodule R M) rfl)
· exact isNoetherian_of_linearEquiv (LinearEquiv.ofTop (⊤ : Submodule R M) rfl).symm
| [
" IsNoetherian R ↥N ↔ ∀ s ≤ N, s.FG",
" s.FG",
" Submodule.map f ⊤ = ⊤",
" IsNoetherian R ↥⊤ ↔ IsNoetherian R M",
" IsNoetherian R ↥⊤ → IsNoetherian R M",
" IsNoetherian R M → IsNoetherian R ↥⊤",
" IsNoetherian R M",
" IsNoetherian R ↥⊤"
] | [
" IsNoetherian R ↥N ↔ ∀ s ≤ N, s.FG",
" s.FG",
" Submodule.map f ⊤ = ⊤"
] |
import Mathlib.Analysis.Calculus.ContDiff.Basic
import Mathlib.Analysis.Calculus.Deriv.Linear
import Mathlib.Analysis.Complex.Conformal
import Mathlib.Analysis.Calculus.Conformal.NormedSpace
#align_import analysis.complex.real_deriv from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
se... | Mathlib/Analysis/Complex/RealDeriv.lean | 99 | 103 | theorem HasStrictDerivAt.complexToReal_fderiv' {f : ℂ → E} {x : ℂ} {f' : E}
(h : HasStrictDerivAt f f' x) :
HasStrictFDerivAt f (reCLM.smulRight f' + I • imCLM.smulRight f') x := by |
simpa only [Complex.restrictScalars_one_smulRight'] using
h.hasStrictFDerivAt.restrictScalars ℝ
| [
" HasStrictDerivAt (fun x => (e ↑x).re) e'.re z",
" e'.re = (reCLM.comp ((ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 e')).comp ofRealCLM)) 1",
" e'.re = reCLM ((ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 e')) (ofRealCLM 1))",
" HasDerivAt (fun x => (e ↑x... | [
" HasStrictDerivAt (fun x => (e ↑x).re) e'.re z",
" e'.re = (reCLM.comp ((ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 e')).comp ofRealCLM)) 1",
" e'.re = reCLM ((ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 e')) (ofRealCLM 1))",
" HasDerivAt (fun x => (e ↑x... |
import Mathlib.MeasureTheory.MeasurableSpace.Basic
import Mathlib.MeasureTheory.Measure.MeasureSpaceDef
#align_import measure_theory.function.ae_measurable_sequence from "leanprover-community/mathlib"@"d003c55042c3cd08aefd1ae9a42ef89441cdaaf3"
open MeasureTheory
open scoped Classical
variable {ι : Sort*} {α β γ... | Mathlib/MeasureTheory/Function/AEMeasurableSequence.lean | 100 | 105 | theorem measure_compl_aeSeqSet_eq_zero [Countable ι] (hf : ∀ i, AEMeasurable (f i) μ)
(hp : ∀ᵐ x ∂μ, p x fun n => f n x) : μ (aeSeqSet hf p)ᶜ = 0 := by |
rw [aeSeqSet, compl_compl, measure_toMeasurable]
have hf_eq := fun i => (hf i).ae_eq_mk
simp_rw [Filter.EventuallyEq, ← ae_all_iff] at hf_eq
exact Filter.Eventually.and hf_eq hp
| [
" μ (aeSeqSet hf p)ᶜ = 0",
" μ {x | (∀ (i : ι), f i x = AEMeasurable.mk (f i) ⋯ x) ∧ p x fun n => f n x}ᶜ = 0"
] | [] |
import Mathlib.GroupTheory.Solvable
import Mathlib.FieldTheory.PolynomialGaloisGroup
import Mathlib.RingTheory.RootsOfUnity.Basic
#align_import field_theory.abel_ruffini from "leanprover-community/mathlib"@"e3f4be1fcb5376c4948d7f095bec45350bfb9d1a"
noncomputable section
open scoped Classical Polynomial Intermedi... | Mathlib/FieldTheory/AbelRuffini.lean | 118 | 153 | theorem gal_X_pow_sub_C_isSolvable_aux (n : ℕ) (a : F)
(h : (X ^ n - 1 : F[X]).Splits (RingHom.id F)) : IsSolvable (X ^ n - C a).Gal := by |
by_cases ha : a = 0
· rw [ha, C_0, sub_zero]
exact gal_X_pow_isSolvable n
have ha' : algebraMap F (X ^ n - C a).SplittingField a ≠ 0 :=
mt ((injective_iff_map_eq_zero _).mp (RingHom.injective _) a) ha
by_cases hn : n = 0
· rw [hn, pow_zero, ← C_1, ← C_sub]
exact gal_C_isSolvable (1 - a)
have hn... | [
" IsSolvable (Gal 0)",
" IsSolvable (Gal 1)",
" IsSolvable (C x).Gal",
" IsSolvable X.Gal",
" IsSolvable (X - C x).Gal",
" IsSolvable (X ^ n).Gal",
" IsSolvable s.prod.Gal",
" IsSolvable (Multiset.prod 0).Gal",
" ∀ {a : F[X]} {s_1 : Multiset F[X]}, a ∈ s → s_1 ⊆ s → IsSolvable s_1.prod.Gal → IsSolva... | [
" IsSolvable (Gal 0)",
" IsSolvable (Gal 1)",
" IsSolvable (C x).Gal",
" IsSolvable X.Gal",
" IsSolvable (X - C x).Gal",
" IsSolvable (X ^ n).Gal",
" IsSolvable s.prod.Gal",
" IsSolvable (Multiset.prod 0).Gal",
" ∀ {a : F[X]} {s_1 : Multiset F[X]}, a ∈ s → s_1 ⊆ s → IsSolvable s_1.prod.Gal → IsSolva... |
import Mathlib.LinearAlgebra.Basis.VectorSpace
import Mathlib.LinearAlgebra.Dimension.Finite
import Mathlib.SetTheory.Cardinal.Subfield
import Mathlib.LinearAlgebra.Dimension.RankNullity
#align_import linear_algebra.dimension from "leanprover-community/mathlib"@"47a5f8186becdbc826190ced4312f8199f9db6a5"
noncomput... | Mathlib/LinearAlgebra/Dimension/DivisionRing.lean | 288 | 300 | theorem rank_fun_infinite {ι : Type v} [hι : Infinite ι] : Module.rank K (ι → K) = #(ι → K) := by |
obtain ⟨⟨ιK, bK⟩⟩ := Module.Free.exists_basis (R := K) (M := ι → K)
obtain ⟨e⟩ := lift_mk_le'.mp ((aleph0_le_mk_iff.mpr hι).trans_eq (lift_uzero #ι).symm)
have := LinearMap.lift_rank_le_of_injective _ <|
LinearMap.funLeft_injective_of_surjective K K _ (invFun_surjective e.injective)
rw [lift_umax.{u,v}, li... | [
" max ℵ₀ #K ≤ Module.rank K (ℕ → K)",
" Injective ⇑Finsupp.lcoeFun",
" #K ≤ Module.rank K (ℕ → K)",
" False",
" #↥L < #K",
" #(ιK × ℕ) < #K",
" ℵ₀ ≤ #ιL",
" #K ≤ #↥L",
" #↥L ^ Fintype.card ιL ≤ #↥L",
" ℵ₀ ≤ #↥L",
" #↥L ^ Fintype.card ιL ≤ ℵ₀",
" ∑ i ∈ t, g i • (⇑bL ∘ ⇑e) i = 0",
" ∑ x ∈ t, ∑... | [
" max ℵ₀ #K ≤ Module.rank K (ℕ → K)",
" Injective ⇑Finsupp.lcoeFun",
" #K ≤ Module.rank K (ℕ → K)",
" False",
" #↥L < #K",
" #(ιK × ℕ) < #K",
" ℵ₀ ≤ #ιL",
" #K ≤ #↥L",
" #↥L ^ Fintype.card ιL ≤ #↥L",
" ℵ₀ ≤ #↥L",
" #↥L ^ Fintype.card ιL ≤ ℵ₀",
" ∑ i ∈ t, g i • (⇑bL ∘ ⇑e) i = 0",
" ∑ x ∈ t, ∑... |
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.SetTheory.Cardinal.Cofinality
import Mathlib.SetTheory.Cardinal.Continuum
#align_import measure_theory.card_measurable_space from "leanprover-community/mathlib"@"f2b108e8e97ba393f22bf794989984ddcc1da89b"
universe u
variable {α : Type u}
open Cardi... | Mathlib/MeasureTheory/MeasurableSpace/Card.lean | 74 | 78 | theorem iUnion_mem_generateMeasurableRec {s : Set (Set α)} {i : ω₁} {f : ℕ → Set α}
(hf : ∀ n, ∃ j < i, f n ∈ generateMeasurableRec s j) :
(⋃ n, f n) ∈ generateMeasurableRec s i := by |
unfold generateMeasurableRec
exact mem_union_right _ ⟨fun n => ⟨f n, let ⟨j, hj, hf⟩ := hf n; mem_iUnion.2 ⟨⟨j, hj⟩, hf⟩⟩, rfl⟩
| [
" (invImage (fun x => x) (hasWellFoundedOut (aleph 1).ord)).1 (↑j) a✝",
" s ⊆ generateMeasurableRec s i",
" s ⊆\n let i := i;\n let S := ⋃ j, generateMeasurableRec s ↑j;\n s ∪ {∅} ∪ compl '' S ∪ range fun f => ⋃ n, ↑(f n)",
" s ⊆ s",
" ∅ ∈ generateMeasurableRec s i",
" ∅ ∈\n let i := i;\n l... | [
" (invImage (fun x => x) (hasWellFoundedOut (aleph 1).ord)).1 (↑j) a✝",
" s ⊆ generateMeasurableRec s i",
" s ⊆\n let i := i;\n let S := ⋃ j, generateMeasurableRec s ↑j;\n s ∪ {∅} ∪ compl '' S ∪ range fun f => ⋃ n, ↑(f n)",
" s ⊆ s",
" ∅ ∈ generateMeasurableRec s i",
" ∅ ∈\n let i := i;\n l... |
import Mathlib.Analysis.Calculus.TangentCone
import Mathlib.Analysis.NormedSpace.OperatorNorm.Asymptotics
#align_import analysis.calculus.fderiv.basic from "leanprover-community/mathlib"@"41bef4ae1254365bc190aee63b947674d2977f01"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open To... | Mathlib/Analysis/Calculus/FDeriv/Basic.lean | 231 | 233 | theorem fderiv_zero_of_not_differentiableAt (h : ¬DifferentiableAt 𝕜 f x) : fderiv 𝕜 f x = 0 := by |
have : ¬∃ f', HasFDerivAt f f' x := h
simp [fderiv, this]
| [
" fderivWithin 𝕜 f s x = 0",
" 𝓝[s \\ {x}] x = ⊥",
" 𝓝[s \\ {x}] x ≤ 𝓝[s] x",
" fderiv 𝕜 f x = 0"
] | [
" fderivWithin 𝕜 f s x = 0",
" 𝓝[s \\ {x}] x = ⊥",
" 𝓝[s \\ {x}] x ≤ 𝓝[s] x"
] |
import Mathlib.Analysis.InnerProductSpace.Basic
import Mathlib.Analysis.NormedSpace.Dual
import Mathlib.MeasureTheory.Function.StronglyMeasurable.Lp
import Mathlib.MeasureTheory.Integral.SetIntegral
#align_import measure_theory.function.ae_eq_of_integral from "leanprover-community/mathlib"@"915591b2bb3ea303648db07284... | Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean | 260 | 284 | theorem ae_nonneg_of_forall_setIntegral_nonneg_of_stronglyMeasurable (hfm : StronglyMeasurable f)
(hf : Integrable f μ) (hf_zero : ∀ s, MeasurableSet s → μ s < ∞ → 0 ≤ ∫ x in s, f x ∂μ) :
0 ≤ᵐ[μ] f := by |
simp_rw [EventuallyLE, Pi.zero_apply]
rw [ae_const_le_iff_forall_lt_measure_zero]
intro b hb_neg
let s := {x | f x ≤ b}
have hs : MeasurableSet s := hfm.measurableSet_le stronglyMeasurable_const
have mus : μ s < ∞ := Integrable.measure_le_lt_top hf hb_neg
have h_int_gt : (∫ x in s, f x ∂μ) ≤ b * (μ s).to... | [
" (∀ᵐ (x : α) ∂μ, c ≤ f x) ↔ ∀ b < c, μ {x | f x ≤ b} = 0",
" μ {a | ¬c ≤ f a} = 0 ↔ ∀ b < c, μ {x | f x ≤ b} = 0",
" μ {a | f a < c} = 0 ↔ ∀ b < c, μ {x | f x ≤ b} = 0",
" μ {a | f a < c} = 0 → ∀ b < c, μ {x | f x ≤ b} = 0",
" μ {x | f x ≤ b} = 0",
" (∀ b < c, μ {x | f x ≤ b} = 0) → μ {a | f a < c} = 0",... | [
" (∀ᵐ (x : α) ∂μ, c ≤ f x) ↔ ∀ b < c, μ {x | f x ≤ b} = 0",
" μ {a | ¬c ≤ f a} = 0 ↔ ∀ b < c, μ {x | f x ≤ b} = 0",
" μ {a | f a < c} = 0 ↔ ∀ b < c, μ {x | f x ≤ b} = 0",
" μ {a | f a < c} = 0 → ∀ b < c, μ {x | f x ≤ b} = 0",
" μ {x | f x ≤ b} = 0",
" (∀ b < c, μ {x | f x ≤ b} = 0) → μ {a | f a < c} = 0",... |
import Mathlib.Control.Monad.Basic
import Mathlib.Control.Monad.Writer
import Mathlib.Init.Control.Lawful
#align_import control.monad.cont from "leanprover-community/mathlib"@"d6814c584384ddf2825ff038e868451a7c956f31"
universe u v w u₀ u₁ v₀ v₁
structure MonadCont.Label (α : Type w) (m : Type u → Type v) (β : Typ... | Mathlib/Control/Monad/Cont.lean | 101 | 105 | theorem monadLift_bind [Monad m] [LawfulMonad m] {α β} (x : m α) (f : α → m β) :
(monadLift (x >>= f) : ContT r m β) = monadLift x >>= monadLift ∘ f := by |
ext
simp only [monadLift, MonadLift.monadLift, (· ∘ ·), (· >>= ·), bind_assoc, id, run,
ContT.monadLift]
| [
" x = y",
" x x✝ = y x✝",
" ∀ {α : Type ?u.2021} (x : ContT r m α), id <$> x = x",
" id <$> x✝ = x✝",
" ∀ {α β : Type ?u.2021} (x : α) (f : α → ContT r m β), pure x >>= f = f x",
" pure x✝ >>= f✝ = f✝ x✝",
" (pure x✝ >>= f✝¹).run f✝ = (f✝¹ x✝).run f✝",
" ∀ {α β γ : Type ?u.2021} (x : ContT r m α) (f :... | [
" x = y",
" x x✝ = y x✝",
" ∀ {α : Type ?u.2021} (x : ContT r m α), id <$> x = x",
" id <$> x✝ = x✝",
" ∀ {α β : Type ?u.2021} (x : α) (f : α → ContT r m β), pure x >>= f = f x",
" pure x✝ >>= f✝ = f✝ x✝",
" (pure x✝ >>= f✝¹).run f✝ = (f✝¹ x✝).run f✝",
" ∀ {α β γ : Type ?u.2021} (x : ContT r m α) (f :... |
import Mathlib.AlgebraicTopology.SimplicialObject
import Mathlib.CategoryTheory.Limits.Shapes.Products
#align_import algebraic_topology.split_simplicial_object from "leanprover-community/mathlib"@"dd1f8496baa505636a82748e6b652165ea888733"
noncomputable section
open CategoryTheory CategoryTheory.Category Category... | Mathlib/AlgebraicTopology/SplitSimplicialObject.lean | 162 | 171 | theorem eqId_iff_mono : A.EqId ↔ Mono A.e := by |
constructor
· intro h
dsimp at h
subst h
dsimp only [id, e]
infer_instance
· intro h
rw [eqId_iff_len_le]
exact len_le_of_mono h
| [
" A₁.fst.unop = A₂.fst.unop",
" A₁ = A₂",
" ⟨Δ₁, ⟨α₁, hα₁⟩⟩ = A₂",
" ⟨Δ₁, ⟨α₁, hα₁⟩⟩ = ⟨Δ₂, ⟨α₂, hα₂⟩⟩",
" ⟨Δ₁, ⟨α₁, hα₁⟩⟩ = ⟨Δ₁, ⟨α₂, hα₂⟩⟩",
" Function.Injective fun A => ⟨⟨A.fst.unop.len, ⋯⟩, ⇑(Hom.toOrderHom A.e)⟩",
" ⟨Δ₁, α₁⟩ = ⟨Δ₂, α₂⟩",
" ⟨{ unop := Δ₁ }, α₁⟩ = ⟨Δ₂, α₂⟩",
" ⟨{ unop := Δ₁ }, α... | [
" A₁.fst.unop = A₂.fst.unop",
" A₁ = A₂",
" ⟨Δ₁, ⟨α₁, hα₁⟩⟩ = A₂",
" ⟨Δ₁, ⟨α₁, hα₁⟩⟩ = ⟨Δ₂, ⟨α₂, hα₂⟩⟩",
" ⟨Δ₁, ⟨α₁, hα₁⟩⟩ = ⟨Δ₁, ⟨α₂, hα₂⟩⟩",
" Function.Injective fun A => ⟨⟨A.fst.unop.len, ⋯⟩, ⇑(Hom.toOrderHom A.e)⟩",
" ⟨Δ₁, α₁⟩ = ⟨Δ₂, α₂⟩",
" ⟨{ unop := Δ₁ }, α₁⟩ = ⟨Δ₂, α₂⟩",
" ⟨{ unop := Δ₁ }, α... |
import Mathlib.Logic.Encodable.Lattice
import Mathlib.MeasureTheory.MeasurableSpace.Defs
#align_import measure_theory.pi_system from "leanprover-community/mathlib"@"98e83c3d541c77cdb7da20d79611a780ff8e7d90"
open MeasurableSpace Set
open scoped Classical
open MeasureTheory
def IsPiSystem {α} (C : Set (Set α)) :... | Mathlib/MeasureTheory/PiSystem.lean | 112 | 120 | theorem isPiSystem_iUnion_of_directed_le {α ι} (p : ι → Set (Set α))
(hp_pi : ∀ n, IsPiSystem (p n)) (hp_directed : Directed (· ≤ ·) p) :
IsPiSystem (⋃ n, p n) := by |
intro t1 ht1 t2 ht2 h
rw [Set.mem_iUnion] at ht1 ht2 ⊢
cases' ht1 with n ht1
cases' ht2 with m ht2
obtain ⟨k, hpnk, hpmk⟩ : ∃ k, p n ≤ p k ∧ p m ≤ p k := hp_directed n m
exact ⟨k, hp_pi k t1 (hpnk ht1) t2 (hpmk ht2) h⟩
| [
" IsPiSystem {S}",
" s ∩ t ∈ {S}",
" IsPiSystem (insert ∅ S)",
" s ∩ t ∈ insert ∅ S",
" IsPiSystem (insert univ S)",
" s ∩ t ∈ insert univ S",
" IsPiSystem {s | ∃ t ∈ S, f ⁻¹' t = s}",
" f ⁻¹' s ∩ f ⁻¹' t ∈ {s | ∃ t ∈ S, f ⁻¹' t = s}",
" f ⁻¹' (s ∩ t) ∈ {s | ∃ t ∈ S, f ⁻¹' t = s}",
" IsPiSystem (⋃... | [
" IsPiSystem {S}",
" s ∩ t ∈ {S}",
" IsPiSystem (insert ∅ S)",
" s ∩ t ∈ insert ∅ S",
" IsPiSystem (insert univ S)",
" s ∩ t ∈ insert univ S",
" IsPiSystem {s | ∃ t ∈ S, f ⁻¹' t = s}",
" f ⁻¹' s ∩ f ⁻¹' t ∈ {s | ∃ t ∈ S, f ⁻¹' t = s}",
" f ⁻¹' (s ∩ t) ∈ {s | ∃ t ∈ S, f ⁻¹' t = s}"
] |
import Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic
#align_import number_theory.legendre_symbol.basic from "leanprover-community/mathlib"@"5b2fe80501ff327b9109fb09b7cc8c325cd0d7d9"
open Nat
section Euler
section Legendre
open ZMod
variable (p : ℕ) [Fact p.Prime]
def legendreSym (a : ℤ) : ℤ :=
... | Mathlib/NumberTheory/LegendreSymbol/Basic.lean | 116 | 132 | theorem eq_pow (a : ℤ) : (legendreSym p a : ZMod p) = (a : ZMod p) ^ (p / 2) := by |
rcases eq_or_ne (ringChar (ZMod p)) 2 with hc | hc
· by_cases ha : (a : ZMod p) = 0
· rw [legendreSym, ha, quadraticChar_zero,
zero_pow (Nat.div_pos (@Fact.out p.Prime).two_le (succ_pos 1)).ne']
norm_cast
· have := (ringChar_zmod_n p).symm.trans hc
-- p = 2
subst p
rw [legen... | [
" ↑(legendreSym p a) = ↑a ^ (p / 2)",
" ↑0 = 0",
" ↑(legendreSym 2 a) = ↑a ^ (2 / 2)",
" ↑1 = ↑a ^ (2 / 2)",
" ¬↑a = 0 → ↑1 = ↑a ^ (2 / 2)",
" ¬↑a = 0 → 1 = ↑a ^ 1",
" ¬b = 0 → 1 = b ^ 1",
" ¬⟨0, ⋯⟩ = 0 → 1 = ⟨0, ⋯⟩ ^ 1",
" ¬⟨1, ⋯⟩ = 0 → 1 = ⟨1, ⋯⟩ ^ 1",
" p = Fintype.card (ZMod p)"
] | [] |
import Mathlib.Algebra.Lie.Matrix
import Mathlib.LinearAlgebra.Matrix.SesquilinearForm
import Mathlib.Tactic.NoncommRing
#align_import algebra.lie.skew_adjoint from "leanprover-community/mathlib"@"075b3f7d19b9da85a0b54b3e33055a74fc388dec"
universe u v w w₁
section SkewAdjointEndomorphisms
open LinearMap (BilinF... | Mathlib/Algebra/Lie/SkewAdjoint.lean | 84 | 86 | theorem skewAdjointLieSubalgebraEquiv_symm_apply (f : skewAdjointLieSubalgebra B) :
↑((skewAdjointLieSubalgebraEquiv B e).symm f) = e.symm.lieConj f := by |
simp [skewAdjointLieSubalgebraEquiv]
| [
" ⁅f, g⁆ ∈ skewAdjointSubmodule B",
" IsSkewAdjoint B ⁅f, g⁆",
" IsAdjointPair B B (f * g) (g * f)",
" IsAdjointPair B B (f * g) (-g * -f)",
" IsAdjointPair B B (g * f) (f * g)",
" IsAdjointPair B B (g * f) (-f * -g)",
" IsAdjointPair B B (f * g - g * f) (-(f * g - g * f))",
" IsAdjointPair B B (f * g... | [
" ⁅f, g⁆ ∈ skewAdjointSubmodule B",
" IsSkewAdjoint B ⁅f, g⁆",
" IsAdjointPair B B (f * g) (g * f)",
" IsAdjointPair B B (f * g) (-g * -f)",
" IsAdjointPair B B (g * f) (f * g)",
" IsAdjointPair B B (g * f) (-f * -g)",
" IsAdjointPair B B (f * g - g * f) (-(f * g - g * f))",
" IsAdjointPair B B (f * g... |
import Mathlib.Algebra.Order.Group.TypeTags
import Mathlib.FieldTheory.RatFunc.Degree
import Mathlib.RingTheory.DedekindDomain.IntegralClosure
import Mathlib.RingTheory.IntegrallyClosed
import Mathlib.Topology.Algebra.ValuedField
#align_import number_theory.function_field from "leanprover-community/mathlib"@"70fd9563... | Mathlib/NumberTheory/FunctionField.lean | 113 | 121 | theorem algebraMap_injective : Function.Injective (⇑(algebraMap Fq[X] (ringOfIntegers Fq F))) := by |
have hinj : Function.Injective (⇑(algebraMap Fq[X] F)) := by
rw [IsScalarTower.algebraMap_eq Fq[X] (RatFunc Fq) F]
exact (algebraMap (RatFunc Fq) F).injective.comp (IsFractionRing.injective Fq[X] (RatFunc Fq))
rw [injective_iff_map_eq_zero (algebraMap Fq[X] (↥(ringOfIntegers Fq F)))]
intro p hp
rw [← S... | [
" FunctionField Fq F ↔ FiniteDimensional Fqt F",
" ∀ (c : RatFunc Fq) (x : F), e c • x = c • x",
" e c • x = c • x",
" (algebraMap Fqt F) (e c) * x = (algebraMap (RatFunc Fq) F) c * x",
" (algebraMap Fqt F) (e c) = (algebraMap (RatFunc Fq) F) c",
" (fun c => (algebraMap Fqt F) (e c)) = ⇑(algebraMap (RatFu... | [
" FunctionField Fq F ↔ FiniteDimensional Fqt F",
" ∀ (c : RatFunc Fq) (x : F), e c • x = c • x",
" e c • x = c • x",
" (algebraMap Fqt F) (e c) * x = (algebraMap (RatFunc Fq) F) c * x",
" (algebraMap Fqt F) (e c) = (algebraMap (RatFunc Fq) F) c",
" (fun c => (algebraMap Fqt F) (e c)) = ⇑(algebraMap (RatFu... |
import Mathlib.Dynamics.Flow
import Mathlib.Tactic.Monotonicity
#align_import dynamics.omega_limit from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Function Filter Topology
section omegaLimit
variable {τ : Type*} {α : Type*} {β : Type*} {ι : Type*}
def omegaLimit [Topol... | Mathlib/Dynamics/OmegaLimit.lean | 150 | 152 | theorem mem_omegaLimit_singleton_iff_map_cluster_point (x : α) (y : β) :
y ∈ ω f ϕ {x} ↔ MapClusterPt y f fun t ↦ ϕ t x := by |
simp_rw [mem_omegaLimit_iff_frequently, mapClusterPt_iff, singleton_inter_nonempty, mem_preimage]
| [
" ω f₁ (fun t x => ϕ (m t) x) s ⊆ ω f₂ ϕ s",
" closure (image2 (fun t x => ϕ (m t) x) (m ⁻¹' u) s) ⊆ closure (image2 ϕ u s)",
" closure (image2 ϕ ((fun t => m t) '' (m ⁻¹' u)) s) ⊆ closure (image2 ϕ u s)",
" MapsTo gb (ω f ϕ s) (ω f ϕ' s')",
" ∀ ⦃x : β⦄, (∀ i ∈ f, x ∈ closure (image2 ϕ i s)) → ∀ i ∈ f, gb x... | [
" ω f₁ (fun t x => ϕ (m t) x) s ⊆ ω f₂ ϕ s",
" closure (image2 (fun t x => ϕ (m t) x) (m ⁻¹' u) s) ⊆ closure (image2 ϕ u s)",
" closure (image2 ϕ ((fun t => m t) '' (m ⁻¹' u)) s) ⊆ closure (image2 ϕ u s)",
" MapsTo gb (ω f ϕ s) (ω f ϕ' s')",
" ∀ ⦃x : β⦄, (∀ i ∈ f, x ∈ closure (image2 ϕ i s)) → ∀ i ∈ f, gb x... |
import Mathlib.CategoryTheory.Abelian.Opposite
import Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero
import Mathlib.CategoryTheory.Limits.Preserves.Shapes.Kernels
import Mathlib.CategoryTheory.Preadditive.LeftExact
import Mathlib.CategoryTheory.Adjunction.Limits
import Mathlib.Algebra.Homology.Exact
import Mathli... | Mathlib/CategoryTheory/Abelian/Exact.lean | 57 | 63 | theorem exact_iff_image_eq_kernel : Exact f g ↔ imageSubobject f = kernelSubobject g := by |
constructor
· intro h
have : IsIso (imageToKernel f g h.w) := have := h.epi; isIso_of_mono_of_epi _
refine Subobject.eq_of_comm (asIso (imageToKernel _ _ h.w)) ?_
simp
· apply exact_of_image_eq_kernel
| [
" Exact f g ↔ imageSubobject f = kernelSubobject g",
" Exact f g → imageSubobject f = kernelSubobject g",
" imageSubobject f = kernelSubobject g",
" (asIso (imageToKernel f g ⋯)).hom ≫ (kernelSubobject g).arrow = (imageSubobject f).arrow",
" imageSubobject f = kernelSubobject g → Exact f g"
] | [] |
import Mathlib.Geometry.Manifold.MFDeriv.FDeriv
noncomputable section
open scoped Manifold
open Bundle Set Topology
section SpecificFunctions
variable {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*} [NormedAddCommGroup E]
[NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H] (I : ModelWithCorners 𝕜 E H)... | Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean | 228 | 244 | theorem hasMFDerivAt_fst (x : M × M') :
HasMFDerivAt (I.prod I') I Prod.fst x
(ContinuousLinearMap.fst 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2)) := by |
refine ⟨continuous_fst.continuousAt, ?_⟩
have :
∀ᶠ y in 𝓝[range (I.prod I')] extChartAt (I.prod I') x x,
(extChartAt I x.1 ∘ Prod.fst ∘ (extChartAt (I.prod I') x).symm) y = y.1 := by
/- porting note: was
apply Filter.mem_of_superset (extChartAt_target_mem_nhdsWithin (I.prod I') x)
mfld_set_t... | [
" HasMFDerivAt (I.prod I') I Prod.fst x (ContinuousLinearMap.fst 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2))",
" HasFDerivWithinAt (writtenInExtChartAt (I.prod I') I x Prod.fst)\n (ContinuousLinearMap.fst 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2)) (range ↑(I.prod I'))\n (↑(extChartAt (I.prod I') x) x... | [] |
import Mathlib.Order.CompleteLattice
import Mathlib.Data.Finset.Lattice
import Mathlib.CategoryTheory.Limits.Shapes.Pullbacks
import Mathlib.CategoryTheory.Category.Preorder
import Mathlib.CategoryTheory.Limits.Shapes.Products
import Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits
#align_import category_theory.limi... | Mathlib/CategoryTheory/Limits/Lattice.lean | 85 | 93 | theorem finite_product_eq_finset_inf [SemilatticeInf α] [OrderTop α] {ι : Type u} [Fintype ι]
(f : ι → α) : ∏ᶜ f = Fintype.elems.inf f := by |
trans
· exact
(IsLimit.conePointUniqueUpToIso (limit.isLimit _)
(finiteLimitCone (Discrete.functor f)).isLimit).to_eq
change Finset.univ.inf (f ∘ discreteEquiv.toEmbedding) = Fintype.elems.inf f
simp only [← Finset.inf_map, Finset.univ_map_equiv_to_embedding]
rfl
| [
" ∀ (J : Type) [𝒥 : SmallCategory J] [inst : FinCategory J], HasLimitsOfShape J α",
" HasLimitsOfShape J α",
" ∀ (J : Type) [𝒥 : SmallCategory J] [inst : FinCategory J], HasColimitsOfShape J α",
" HasColimitsOfShape J α",
" ∏ᶜ f = Fintype.elems.inf f",
" ∏ᶜ f = ?m.21382",
" (finiteLimitCone (Discrete.... | [
" ∀ (J : Type) [𝒥 : SmallCategory J] [inst : FinCategory J], HasLimitsOfShape J α",
" HasLimitsOfShape J α",
" ∀ (J : Type) [𝒥 : SmallCategory J] [inst : FinCategory J], HasColimitsOfShape J α",
" HasColimitsOfShape J α"
] |
import Mathlib.SetTheory.Cardinal.Finite
#align_import data.set.ncard from "leanprover-community/mathlib"@"74c2af38a828107941029b03839882c5c6f87a04"
namespace Set
variable {α β : Type*} {s t : Set α}
noncomputable def encard (s : Set α) : ℕ∞ := PartENat.withTopEquiv (PartENat.card s)
@[simp] theorem encard_uni... | Mathlib/Data/Set/Card.lean | 85 | 88 | theorem Infinite.encard_eq {s : Set α} (h : s.Infinite) : s.encard = ⊤ := by |
have := h.to_subtype
rw [encard, ← PartENat.withTopEquiv.symm.injective.eq_iff, Equiv.symm_apply_apply,
PartENat.withTopEquiv_symm_top, PartENat.card_eq_top_of_infinite]
| [
" univ.encard = s.encard",
" univ.encard = PartENat.withTopEquiv (PartENat.card α)",
" s.encard = ↑h.toFinset.card",
" s.encard = ↑s.toFinset.card",
" (↑s).encard = ↑s.card",
" ↑⋯.toFinset.card = ↑s.card",
" s.encard = ⊤"
] | [
" univ.encard = s.encard",
" univ.encard = PartENat.withTopEquiv (PartENat.card α)",
" s.encard = ↑h.toFinset.card",
" s.encard = ↑s.toFinset.card",
" (↑s).encard = ↑s.card",
" ↑⋯.toFinset.card = ↑s.card"
] |
import Mathlib.Tactic.Ring
set_option autoImplicit true
namespace Mathlib.Tactic.LinearCombination
open Lean hiding Rat
open Elab Meta Term
theorem pf_add_c [Add α] (p : a = b) (c : α) : a + c = b + c := p ▸ rfl
theorem c_add_pf [Add α] (p : b = c) (a : α) : a + b = a + c := p ▸ rfl
theorem add_pf [Add α] (p₁ : (... | Mathlib/Tactic/LinearCombination.lean | 114 | 116 | theorem eq_of_add_pow [Ring α] [NoZeroDivisors α] (n : ℕ) (p : (a:α) = b)
(H : (a' - b')^n - (a - b) = 0) : a' = b' := by |
rw [← sub_eq_zero] at p ⊢; apply pow_eq_zero (n := n); rwa [sub_eq_zero, p] at H
| [
" a' = b'",
" a' - b' = 0",
" (a' - b') ^ n = 0"
] | [
" a' = b'",
" a' - b' = 0"
] |
import Mathlib.Topology.Algebra.InfiniteSum.Basic
import Mathlib.Topology.Algebra.UniformGroup
noncomputable section
open Filter Finset Function
open scoped Topology
variable {α β γ δ : Type*}
section TopologicalGroup
variable [CommGroup α] [TopologicalSpace α] [TopologicalGroup α]
variable {f g : β → α} {a a₁... | Mathlib/Topology/Algebra/InfiniteSum/Group.lean | 91 | 96 | theorem HasProd.hasProd_compl_iff {s : Set β} (hf : HasProd (f ∘ (↑) : s → α) a₁) :
HasProd (f ∘ (↑) : ↑sᶜ → α) a₂ ↔ HasProd f (a₁ * a₂) := by |
refine ⟨fun h ↦ hf.mul_compl h, fun h ↦ ?_⟩
rw [hasProd_subtype_iff_mulIndicator] at hf ⊢
rw [Set.mulIndicator_compl]
simpa only [div_eq_mul_inv, mul_inv_cancel_comm] using h.div hf
| [
" HasProd (fun b => (f b)⁻¹) a⁻¹",
" Multipliable f",
" HasProd (fun b => f b / g b) (a₁ / a₂)",
" HasProd (fun b => f b * (g b)⁻¹) (a₁ * a₂⁻¹)",
" Multipliable fun b => g b / f b",
" HasProd (Function.update f b a) (a / f b * a₁)",
" Function.update f b a b' = (if b' = b then a / f b else 1) * f b'",
... | [
" HasProd (fun b => (f b)⁻¹) a⁻¹",
" Multipliable f",
" HasProd (fun b => f b / g b) (a₁ / a₂)",
" HasProd (fun b => f b * (g b)⁻¹) (a₁ * a₂⁻¹)",
" Multipliable fun b => g b / f b",
" HasProd (Function.update f b a) (a / f b * a₁)",
" Function.update f b a b' = (if b' = b then a / f b else 1) * f b'",
... |
import Mathlib.Order.ConditionallyCompleteLattice.Basic
import Mathlib.Order.LatticeIntervals
import Mathlib.Order.Interval.Set.OrdConnected
#align_import order.complete_lattice_intervals from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
open scoped Classical
open Set
variable {ι : ... | Mathlib/Order/CompleteLatticeIntervals.lean | 57 | 59 | theorem subset_sSup_of_within [Inhabited s] {t : Set s}
(h' : t.Nonempty) (h'' : BddAbove t) (h : sSup ((↑) '' t : Set α) ∈ s) :
sSup ((↑) '' t : Set α) = (@sSup s _ t : α) := by | simp [dif_pos, h, h', h'']
| [
" sSup (Subtype.val '' t) = ↑(sSup t)"
] | [] |
import Mathlib.AlgebraicTopology.DoldKan.GammaCompN
import Mathlib.AlgebraicTopology.DoldKan.NReflectsIso
#align_import algebraic_topology.dold_kan.n_comp_gamma from "leanprover-community/mathlib"@"32a7e535287f9c73f2e4d2aef306a39190f0b504"
noncomputable section
open CategoryTheory CategoryTheory.Category Categor... | Mathlib/AlgebraicTopology/DoldKan/NCompGamma.lean | 38 | 78 | theorem PInfty_comp_map_mono_eq_zero (X : SimplicialObject C) {n : ℕ} {Δ' : SimplexCategory}
(i : Δ' ⟶ [n]) [hi : Mono i] (h₁ : Δ'.len ≠ n) (h₂ : ¬Isδ₀ i) :
PInfty.f n ≫ X.map i.op = 0 := by |
induction' Δ' using SimplexCategory.rec with m
obtain ⟨k, hk⟩ := Nat.exists_eq_add_of_lt (len_lt_of_mono i fun h => by
rw [← h] at h₁
exact h₁ rfl)
simp only [len_mk] at hk
rcases k with _|k
· change n = m + 1 at hk
subst hk
obtain ⟨j, rfl⟩ := eq_δ_of_mono i
rw [Isδ₀.iff] at h₂
... | [
" PInfty.f n ≫ X.map i.op = 0",
" False",
" PInfty.f (m + 1) ≫ X.map i.op = 0",
" PInfty.f (m + 1) ≫ X.map (SimplexCategory.δ j).op = 0",
" 1 ≤ ↑j",
" j = 0",
" m + 2 ≤ ↑j + (m + 1)",
" PInfty.f (m + k + 1 + 1) ≫ X.map i.op = 0",
" PInfty.f (m + k + 1 + 1) ≫ X.map (i ≫ SimplexCategory.δ j₁).op = 0",... | [] |
import Mathlib.GroupTheory.GroupAction.Basic
import Mathlib.Topology.Algebra.ConstMulAction
#align_import dynamics.minimal from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
open Pointwise
class AddAction.IsMinimal (M α : Type*) [AddMonoid M] [TopologicalSpace α] [AddAction M α] :
... | Mathlib/Dynamics/Minimal.lean | 119 | 126 | theorem isMinimal_iff_closed_smul_invariant [ContinuousConstSMul M α] :
IsMinimal M α ↔ ∀ s : Set α, IsClosed s → (∀ c : M, c • s ⊆ s) → s = ∅ ∨ s = univ := by |
constructor
· intro _ _
exact eq_empty_or_univ_of_smul_invariant_closed M
refine fun H ↦ ⟨fun _ ↦ dense_iff_closure_eq.2 <| (H _ ?_ ?_).resolve_left ?_⟩
exacts [isClosed_closure, fun _ ↦ smul_closure_orbit_subset _ _,
(orbit_nonempty _).closure.ne_empty]
| [
" IsMinimal M α ↔ ∀ (s : Set α), IsClosed s → (∀ (c : M), c • s ⊆ s) → s = ∅ ∨ s = univ",
" IsMinimal M α → ∀ (s : Set α), IsClosed s → (∀ (c : M), c • s ⊆ s) → s = ∅ ∨ s = univ",
" IsClosed s✝ → (∀ (c : M), c • s✝ ⊆ s✝) → s✝ = ∅ ∨ s✝ = univ",
" (∀ (s : Set α), IsClosed s → (∀ (c : M), c • s ⊆ s) → s = ∅ ∨ s ... | [] |
import Mathlib.Data.Countable.Basic
import Mathlib.Data.Fin.VecNotation
import Mathlib.Order.Disjointed
import Mathlib.MeasureTheory.OuterMeasure.Defs
#align_import measure_theory.measure.outer_measure from "leanprover-community/mathlib"@"343e80208d29d2d15f8050b929aa50fe4ce71b55"
noncomputable section
open Set F... | Mathlib/MeasureTheory/OuterMeasure/Basic.lean | 103 | 107 | theorem measure_biUnion_null_iff {I : Set ι} (hI : I.Countable) {s : ι → Set α} :
μ (⋃ i ∈ I, s i) = 0 ↔ ∀ i ∈ I, μ (s i) = 0 := by |
refine ⟨fun h i hi ↦ measure_mono_null (subset_biUnion_of_mem hi) h, fun h ↦ ?_⟩
have _ := hI.to_subtype
simpa [h] using measure_iUnion_le (μ := μ) fun x : I ↦ s x
| [
" μ (⋃ i, s i) ≤ ∑' (i : ι), μ (s i)",
" (fun x x_1 => x ≤ x_1) (μ (⨆ i, t i)) (∑' (i : ℕ), μ (t i))",
" μ (⋃ i, t i) = μ (⋃ i, disjointed t i)",
" ∑' (i : ℕ), μ (disjointed t i) ≤ ∑' (i : ℕ), μ (t i)",
" disjointed t a✝ ⊆ t a✝",
" μ (⋃ i ∈ I, s i) ≤ ∑' (i : ↑I), μ (s ↑i)",
" μ (⋃ x, s ↑x) ≤ ∑' (i : ↑I)... | [
" μ (⋃ i, s i) ≤ ∑' (i : ι), μ (s i)",
" (fun x x_1 => x ≤ x_1) (μ (⨆ i, t i)) (∑' (i : ℕ), μ (t i))",
" μ (⋃ i, t i) = μ (⋃ i, disjointed t i)",
" ∑' (i : ℕ), μ (disjointed t i) ≤ ∑' (i : ℕ), μ (t i)",
" disjointed t a✝ ⊆ t a✝",
" μ (⋃ i ∈ I, s i) ≤ ∑' (i : ↑I), μ (s ↑i)",
" μ (⋃ x, s ↑x) ≤ ∑' (i : ↑I)... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.