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.Algebra.Group.Indicator
import Mathlib.Algebra.Group.Submonoid.Basic
import Mathlib.Data.Set.Finite
#align_import data.finsupp.defs from "leanprover-community/mathlib"@"842328d9df7e96fd90fc424e115679c15fb23a71"
noncomputable section
open Finset Function
variable {α β γ ι M M' N P G H R S : Type*}... | Mathlib/Data/Finsupp/Defs.lean | 209 | 209 | theorem card_support_eq_zero {f : α →₀ M} : card f.support = 0 ↔ f = 0 := by | simp
| [
" Injective toFun",
" { support := s, toFun := f, mem_support_toFun := hf } = { support := t, toFun := f, mem_support_toFun := hg }",
" s = t",
" a ∈ s ↔ a ∈ t",
" ⇑f = 0 ↔ f = 0",
" f a = g a",
" g a = 0",
" f.support.Nonempty ↔ f ≠ 0",
" f.support.card = 0 ↔ f = 0"
] | [
" Injective toFun",
" { support := s, toFun := f, mem_support_toFun := hf } = { support := t, toFun := f, mem_support_toFun := hg }",
" s = t",
" a ∈ s ↔ a ∈ t",
" ⇑f = 0 ↔ f = 0",
" f a = g a",
" g a = 0",
" f.support.Nonempty ↔ f ≠ 0"
] |
import Mathlib.SetTheory.Cardinal.ToNat
import Mathlib.Data.Nat.PartENat
#align_import set_theory.cardinal.basic from "leanprover-community/mathlib"@"3ff3f2d6a3118b8711063de7111a0d77a53219a8"
universe u v
open Function
variable {α : Type u}
namespace Cardinal
noncomputable def toPartENat : Cardinal →+o PartEN... | Mathlib/SetTheory/Cardinal/PartENat.lean | 39 | 40 | theorem toPartENat_natCast (n : ℕ) : toPartENat n = n := by |
simp only [← partENatOfENat_toENat, toENat_nat, PartENat.ofENat_coe]
| [
" toPartENat ↑n = ↑n"
] | [] |
import Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar
import Mathlib.MeasureTheory.Covering.Besicovitch
import Mathlib.Tactic.AdaptationNote
#align_import measure_theory.covering.besicovitch_vector_space from "leanprover-community/mathlib"@"fd5edc43dc4f10b85abfe544b88f82cf13c5f844"
universe u
open Metric Set Fini... | Mathlib/MeasureTheory/Covering/BesicovitchVectorSpace.lean | 160 | 167 | theorem card_le_multiplicity {s : Finset E} (hs : ∀ c ∈ s, ‖c‖ ≤ 2)
(h's : ∀ c ∈ s, ∀ d ∈ s, c ≠ d → 1 ≤ ‖c - d‖) : s.card ≤ multiplicity E := by |
apply le_csSup
· refine ⟨5 ^ finrank ℝ E, ?_⟩
rintro _ ⟨s, ⟨rfl, h⟩⟩
exact Besicovitch.card_le_of_separated s h.1 h.2
· simp only [mem_setOf_eq, Ne]
exact ⟨s, rfl, hs, h's⟩
| [
" s.card ≤ 5 ^ finrank ℝ E",
" 0 < ρ",
" (↑s).Pairwise (Disjoint on fun c => ball c δ)",
" (Disjoint on fun c => ball c δ) c d",
" δ + δ ≤ dist c d",
" δ + δ ≤ ‖c - d‖",
" δ + δ = 1",
" A ⊆ ball 0 ρ",
" ball x δ ⊆ ball 0 ρ",
" δ + dist x 0 ≤ ρ",
" δ + dist x 0 ≤ δ + 2",
" δ + ‖x‖ ≤ δ + 2",
"... | [
" s.card ≤ 5 ^ finrank ℝ E",
" 0 < ρ",
" (↑s).Pairwise (Disjoint on fun c => ball c δ)",
" (Disjoint on fun c => ball c δ) c d",
" δ + δ ≤ dist c d",
" δ + δ ≤ ‖c - d‖",
" δ + δ = 1",
" A ⊆ ball 0 ρ",
" ball x δ ⊆ ball 0 ρ",
" δ + dist x 0 ≤ ρ",
" δ + dist x 0 ≤ δ + 2",
" δ + ‖x‖ ≤ δ + 2",
"... |
import Mathlib.Analysis.NormedSpace.AffineIsometry
import Mathlib.Topology.Algebra.ContinuousAffineMap
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
#align_import analysis.normed_space.continuous_affine_map from "leanprover-community/mathlib"@"17ef379e997badd73e5eabb4d38f11919ab3c4b3"
namespace Con... | Mathlib/Analysis/NormedSpace/ContinuousAffineMap.lean | 118 | 120 | theorem to_affine_map_contLinear (f : V →L[R] W) : f.toContinuousAffineMap.contLinear = f := by |
ext
rfl
| [
" Continuous { toFun := ⇑f.linear, map_add' := ⋯, map_smul' := ⋯ }.toFun",
" Continuous ⇑f.toAffineMap",
" ↑f.contLinear = f.linear",
" ↑f.contLinear x✝ = f.linear x✝",
" f.contLinear = 0 ↔ ∃ q, f = const R P q",
" f.contLinear = 0 ↔ f.linear = 0",
" f.linear = 0",
" f.contLinear = 0",
" f.linear x✝... | [
" Continuous { toFun := ⇑f.linear, map_add' := ⋯, map_smul' := ⋯ }.toFun",
" Continuous ⇑f.toAffineMap",
" ↑f.contLinear = f.linear",
" ↑f.contLinear x✝ = f.linear x✝",
" f.contLinear = 0 ↔ ∃ q, f = const R P q",
" f.contLinear = 0 ↔ f.linear = 0",
" f.linear = 0",
" f.contLinear = 0",
" f.linear x✝... |
import Mathlib.MeasureTheory.Integral.SetToL1
#align_import measure_theory.integral.bochner from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"
assert_not_exists Differentiable
noncomputable section
open scoped Topology NNReal ENNReal MeasureTheory
open Set Filter TopologicalSpace EN... | Mathlib/MeasureTheory/Integral/Bochner.lean | 176 | 177 | theorem weightedSMul_zero_measure {m : MeasurableSpace α} :
weightedSMul (0 : Measure α) = (0 : Set α → F →L[ℝ] F) := by | ext1; simp [weightedSMul]
| [
" (weightedSMul μ s) x = (μ s).toReal • x",
" weightedSMul 0 = 0",
" weightedSMul 0 x✝ = 0 x✝"
] | [
" (weightedSMul μ s) x = (μ s).toReal • x"
] |
import Mathlib.Algebra.MvPolynomial.Equiv
import Mathlib.Algebra.MvPolynomial.Supported
import Mathlib.LinearAlgebra.LinearIndependent
import Mathlib.RingTheory.Adjoin.Basic
import Mathlib.RingTheory.Algebraic
import Mathlib.RingTheory.MvPolynomial.Basic
#align_import ring_theory.algebraic_independent from "leanprove... | Mathlib/RingTheory/AlgebraicIndependent.lean | 109 | 118 | theorem linearIndependent : LinearIndependent R x := by |
rw [linearIndependent_iff_injective_total]
have : Finsupp.total ι A R x =
(MvPolynomial.aeval x).toLinearMap.comp (Finsupp.total ι _ R X) := by
ext
simp
rw [this]
refine hx.comp ?_
rw [← linearIndependent_iff_injective_total]
exact linearIndependent_X _ _
| [
" AlgebraicIndependent R x ↔ Injective ⇑(algebraMap R A)",
" aeval x = (ofId R A).comp ↑(isEmptyAlgEquiv R ι)",
" (aeval x) (X i) = ((ofId R A).comp ↑(isEmptyAlgEquiv R ι)) (X i)",
" Injective ⇑((ofId R A).comp ↑(isEmptyAlgEquiv R ι)) ↔ Injective (⇑(algebraMap R A) ∘ ⇑(isEmptyAlgEquiv R ι))",
" Injective ⇑(... | [
" AlgebraicIndependent R x ↔ Injective ⇑(algebraMap R A)",
" aeval x = (ofId R A).comp ↑(isEmptyAlgEquiv R ι)",
" (aeval x) (X i) = ((ofId R A).comp ↑(isEmptyAlgEquiv R ι)) (X i)",
" Injective ⇑((ofId R A).comp ↑(isEmptyAlgEquiv R ι)) ↔ Injective (⇑(algebraMap R A) ∘ ⇑(isEmptyAlgEquiv R ι))",
" Injective ⇑(... |
import Mathlib.Data.Set.Image
import Mathlib.Data.SProd
#align_import data.set.prod from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"
open Function
namespace Set
section Prod
variable {α β γ δ : Type*} {s s₁ s₂ : Set α} {t t₁ t₂ : Set β} {a : α} {b : β}
theorem Subsingleton.pro... | Mathlib/Data/Set/Prod.lean | 96 | 98 | theorem univ_prod_univ : @univ α ×ˢ @univ β = univ := by |
ext
exact true_and_iff _
| [
" (∃ x ∈ s ×ˢ t, p x) ↔ ∃ x ∈ s, ∃ y ∈ t, p (x, y)",
" s ×ˢ ∅ = ∅",
" x✝ ∈ s ×ˢ ∅ ↔ x✝ ∈ ∅",
" ∅ ×ˢ t = ∅",
" x✝ ∈ ∅ ×ˢ t ↔ x✝ ∈ ∅",
" univ ×ˢ univ = univ",
" x✝ ∈ univ ×ˢ univ ↔ x✝ ∈ univ"
] | [
" (∃ x ∈ s ×ˢ t, p x) ↔ ∃ x ∈ s, ∃ y ∈ t, p (x, y)",
" s ×ˢ ∅ = ∅",
" x✝ ∈ s ×ˢ ∅ ↔ x✝ ∈ ∅",
" ∅ ×ˢ t = ∅",
" x✝ ∈ ∅ ×ˢ t ↔ x✝ ∈ ∅"
] |
import Mathlib.Algebra.Quaternion
import Mathlib.Tactic.Ring
#align_import algebra.quaternion_basis from "leanprover-community/mathlib"@"3aa5b8a9ed7a7cabd36e6e1d022c9858ab8a8c2d"
open Quaternion
namespace QuaternionAlgebra
structure Basis {R : Type*} (A : Type*) [CommRing R] [Ring A] [Algebra R A] (c₁ c₂ : R) ... | Mathlib/Algebra/QuaternionBasis.lean | 114 | 114 | theorem lift_zero : q.lift (0 : ℍ[R,c₁,c₂]) = 0 := by | simp [lift]
| [
" q₁ = q₂",
" { i := i✝, j := j✝, k := k✝, i_mul_i := i_mul_i✝, j_mul_j := j_mul_j✝, i_mul_j := i_mul_j✝, j_mul_i := j_mul_i✝ } = q₂",
" { i := i✝, j := j✝, k := k✝, i_mul_i := i_mul_i✝, j_mul_j := j_mul_j✝, i_mul_j := q₁_i_mul_j, j_mul_i := j_mul_i✝ } =\n q₂",
" { i := i✝¹, j := j✝¹, k := k✝¹, i_mul_i := ... | [
" q₁ = q₂",
" { i := i✝, j := j✝, k := k✝, i_mul_i := i_mul_i✝, j_mul_j := j_mul_j✝, i_mul_j := i_mul_j✝, j_mul_i := j_mul_i✝ } = q₂",
" { i := i✝, j := j✝, k := k✝, i_mul_i := i_mul_i✝, j_mul_j := j_mul_j✝, i_mul_j := q₁_i_mul_j, j_mul_i := j_mul_i✝ } =\n q₂",
" { i := i✝¹, j := j✝¹, k := k✝¹, i_mul_i := ... |
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 | 58 | 59 | theorem part_num_eq_s_a {gp : Pair α} (s_nth_eq : g.s.get? n = some gp) :
g.partialNumerators.get? n = some gp.a := by | simp [partialNumerators, s_nth_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.LinearAlgebra.Dimension.DivisionRing
import Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition
noncomputable section
universe u v v' v''
variable {K : Type u} {V V₁ : Type v} {V' V'₁ : Type v'} {V'' : Type v''}
open Cardinal Basis Submodule Function Set
namespace LinearMap
section Ring
... | Mathlib/LinearAlgebra/Dimension/LinearMap.lean | 79 | 81 | theorem rank_comp_le (g : V →ₗ[K] V') (f : V' →ₗ[K] V'₁) :
rank (f.comp g) ≤ min (rank f) (rank g) := by |
simpa only [Cardinal.lift_id] using lift_rank_comp_le g f
| [
" rank 0 = 0",
" (f ∘ₗ g).rank ≤ f.rank",
" range (f ∘ₗ g) ≤ range f",
" Submodule.map f (range g) ≤ range f",
" lift.{v', v''} (f ∘ₗ g).rank ≤ lift.{v'', v'} g.rank",
" lift.{v', v''} (Module.rank K ↥(Submodule.map f (range g))) ≤ lift.{v'', v'} (Module.rank K ↥(range g))",
" (f ∘ₗ g).rank ≤ g.rank",
... | [
" rank 0 = 0",
" (f ∘ₗ g).rank ≤ f.rank",
" range (f ∘ₗ g) ≤ range f",
" Submodule.map f (range g) ≤ range f",
" lift.{v', v''} (f ∘ₗ g).rank ≤ lift.{v'', v'} g.rank",
" lift.{v', v''} (Module.rank K ↥(Submodule.map f (range g))) ≤ lift.{v'', v'} (Module.rank K ↥(range g))",
" (f ∘ₗ g).rank ≤ g.rank"
] |
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 | 127 | 136 | theorem mem_omegaLimit_iff_frequently (y : β) :
y ∈ ω f ϕ s ↔ ∀ n ∈ 𝓝 y, ∃ᶠ t in f, (s ∩ ϕ t ⁻¹' n).Nonempty := by |
simp_rw [frequently_iff, omegaLimit_def, mem_iInter, mem_closure_iff_nhds]
constructor
· intro h _ hn _ hu
rcases h _ hu _ hn with ⟨_, _, _, ht, _, hx, rfl⟩
exact ⟨_, ht, _, hx, by rwa [mem_preimage]⟩
· intro h _ hu _ hn
rcases h _ hn hu with ⟨_, ht, _, hx, hϕtx⟩
exact ⟨_, hϕtx, _, ht, _, hx, r... | [
" ω 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.MeasureTheory.Measure.VectorMeasure
#align_import measure_theory.measure.complex from "leanprover-community/mathlib"@"17b3357baa47f48697ca9c243e300eb8cdd16a15"
noncomputable section
open scoped Classical MeasureTheory ENNReal NNReal
variable {α β : Type*} {m : MeasurableSpace α}
namespace Measur... | Mathlib/MeasureTheory/Measure/Complex.lean | 116 | 122 | theorem absolutelyContinuous_ennreal_iff (c : ComplexMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
c ≪ᵥ μ ↔ ComplexMeasure.re c ≪ᵥ μ ∧ ComplexMeasure.im c ≪ᵥ μ := by |
constructor <;> intro h
· constructor <;> · intro i hi; simp [h hi]
· intro i hi
rw [← Complex.re_add_im (c i), (_ : (c i).re = 0), (_ : (c i).im = 0)]
exacts [by simp, h.2 hi, h.1 hi]
| [
" (fun i => { re := ↑s i, im := ↑t i }) ∅ = 0",
" { re := ↑s ∅, im := ↑t ∅ } = 0",
" { re := 0, im := 0 } = 0",
" (fun i => { re := ↑s i, im := ↑t i }) i = 0",
" { re := ↑s i, im := ↑t i } = 0",
" __src✝.toFun (c + d) = __src✝.toFun c + __src✝.toFun d",
" ∀ (m_1 : R) (x : ComplexMeasure α),\n { toFun... | [
" (fun i => { re := ↑s i, im := ↑t i }) ∅ = 0",
" { re := ↑s ∅, im := ↑t ∅ } = 0",
" { re := 0, im := 0 } = 0",
" (fun i => { re := ↑s i, im := ↑t i }) i = 0",
" { re := ↑s i, im := ↑t i } = 0",
" __src✝.toFun (c + d) = __src✝.toFun c + __src✝.toFun d",
" ∀ (m_1 : R) (x : ComplexMeasure α),\n { toFun... |
import Mathlib.Algebra.Polynomial.Splits
import Mathlib.RingTheory.MvPolynomial.Symmetric
#align_import ring_theory.polynomial.vieta from "leanprover-community/mathlib"@"f694c7dead66f5d4c80f446c796a5aad14707f0e"
open Polynomial
namespace Multiset
open Polynomial
section Ring
variable {R : Type*} [CommRing R]
... | Mathlib/RingTheory/Polynomial/Vieta.lean | 94 | 101 | theorem esymm_neg (s : Multiset R) (k : ℕ) : (map Neg.neg s).esymm k = (-1) ^ k * esymm s k := by |
rw [esymm, esymm, ← Multiset.sum_map_mul_left, Multiset.powersetCard_map, Multiset.map_map,
map_congr rfl]
intro x hx
rw [(mem_powersetCard.mp hx).right.symm, ← prod_replicate, ← Multiset.map_const]
nth_rw 3 [← map_id' x]
rw [← prod_map_mul, map_congr rfl, Function.comp_apply]
exact fun z _ => neg_one_... | [
" (map Neg.neg s).esymm k = (-1) ^ k * s.esymm k",
" ∀ x ∈ powersetCard k s, (prod ∘ map Neg.neg) x = (-1) ^ k * x.prod",
" (prod ∘ map Neg.neg) x = (-1) ^ k * x.prod",
" (prod ∘ map Neg.neg) x = (map (Function.const R (-1)) x).prod * x.prod",
" (prod ∘ map Neg.neg) x = (map (Function.const R (-1)) x).prod ... | [] |
import Mathlib.Algebra.CharP.Invertible
import Mathlib.Algebra.Order.Invertible
import Mathlib.Algebra.Order.Module.OrderedSMul
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.LinearAlgebra.AffineSpace.Slope
import Mathlib.LinearAlgebra.AffineSpace.Midpoint
import Mathlib.Tactic.FieldSimp
#align_import li... | Mathlib/LinearAlgebra/AffineSpace/Ordered.lean | 206 | 213 | theorem map_le_lineMap_iff_slope_le_slope_left (h : 0 < r * (b - a)) :
f c ≤ lineMap (f a) (f b) r ↔ slope f a c ≤ slope f a b := by |
rw [lineMap_apply, lineMap_apply, slope, slope, vsub_eq_sub, vsub_eq_sub, vsub_eq_sub,
vadd_eq_add, vadd_eq_add, smul_eq_mul, add_sub_cancel_right, smul_sub, smul_sub, smul_sub,
sub_le_iff_le_add, mul_inv_rev, mul_smul, mul_smul, ← smul_sub, ← smul_sub, ← smul_add,
smul_smul, ← mul_inv_rev, inv_smul_le_i... | [
" (lineMap a b) r ≤ (lineMap a b) r' ↔ a ≤ b",
" (1 - r) • a + r • b ≤ (1 - r') • a + r' • b ↔ a ≤ b",
" a ≤ (lineMap a b) r ↔ (lineMap a b) 0 ≤ (lineMap a b) r",
" (lineMap a b) r ≤ b ↔ (lineMap a b) r ≤ (lineMap a b) 1",
" f ((lineMap a b) r) ≤ (lineMap (f a) (f b)) r ↔ slope f a ((lineMap a b) r) ≤ slope... | [
" (lineMap a b) r ≤ (lineMap a b) r' ↔ a ≤ b",
" (1 - r) • a + r • b ≤ (1 - r') • a + r' • b ↔ a ≤ b",
" a ≤ (lineMap a b) r ↔ (lineMap a b) 0 ≤ (lineMap a b) r",
" (lineMap a b) r ≤ b ↔ (lineMap a b) r ≤ (lineMap a b) 1"
] |
import Mathlib.Data.Set.Basic
#align_import data.bundle from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
open Function Set
namespace Bundle
variable {B F : Type*} (E : B → Type*)
@[ext]
structure TotalSpace (F : Type*) (E : B → Type*) where
proj : B
snd : E proj
#align bund... | Mathlib/Data/Bundle.lean | 74 | 75 | theorem TotalSpace.mk_inj {b : B} {y y' : E b} : mk' F b y = mk' F b y' ↔ y = y' := by |
simp [TotalSpace.ext_iff]
| [
" mk' F x' (cast ⋯ b) = { proj := x, snd := b }",
" mk' F x (cast ⋯ b) = { proj := x, snd := b }",
" mk' F b y = mk' F b y' ↔ y = y'"
] | [
" mk' F x' (cast ⋯ b) = { proj := x, snd := b }",
" mk' F x (cast ⋯ b) = { proj := x, snd := b }"
] |
import Mathlib.GroupTheory.GroupAction.ConjAct
import Mathlib.GroupTheory.GroupAction.Quotient
import Mathlib.GroupTheory.QuotientGroup
import Mathlib.Topology.Algebra.Monoid
import Mathlib.Topology.Algebra.Constructions
#align_import topology.algebra.group.basic from "leanprover-community/mathlib"@"3b1890e71632be9e3... | Mathlib/Topology/Algebra/Group/Basic.lean | 71 | 73 | theorem Homeomorph.mulLeft_symm (a : G) : (Homeomorph.mulLeft a).symm = Homeomorph.mulLeft a⁻¹ := by |
ext
rfl
| [
" (Homeomorph.mulLeft a).symm = Homeomorph.mulLeft a⁻¹",
" (Homeomorph.mulLeft a).symm x✝ = (Homeomorph.mulLeft a⁻¹) x✝"
] | [] |
import Mathlib.Data.ZMod.Basic
import Mathlib.GroupTheory.Coxeter.Basic
namespace CoxeterSystem
open List Matrix Function Classical
variable {B : Type*}
variable {W : Type*} [Group W]
variable {M : CoxeterMatrix B} (cs : CoxeterSystem M W)
local prefix:100 "s" => cs.simple
local prefix:100 "π" => cs.wordProd
... | Mathlib/GroupTheory/Coxeter/Length.lean | 111 | 113 | theorem length_mul_ge_length_sub_length' (w₁ w₂ : W) :
ℓ w₂ - ℓ w₁ ≤ ℓ (w₁ * w₂) := by |
simpa [Nat.sub_le_of_le_add, add_comm] using cs.length_mul_le w₁⁻¹ (w₁ * w₂)
| [
" ∃ n ω, ω.length = n ∧ cs.wordProd ω = w",
" ∃ n ω_1, ω_1.length = n ∧ cs.wordProd ω_1 = cs.wordProd ω",
" ∃ ω, ω.length = cs.length w ∧ w = cs.wordProd ω",
" ω.length = ω.length ∧ cs.wordProd ω = cs.wordProd ω",
" cs.length w = 0 ↔ w = 1",
" cs.length w = 0 → w = 1",
" w = 1",
" cs.wordProd ω = 1",
... | [
" ∃ n ω, ω.length = n ∧ cs.wordProd ω = w",
" ∃ n ω_1, ω_1.length = n ∧ cs.wordProd ω_1 = cs.wordProd ω",
" ∃ ω, ω.length = cs.length w ∧ w = cs.wordProd ω",
" ω.length = ω.length ∧ cs.wordProd ω = cs.wordProd ω",
" cs.length w = 0 ↔ w = 1",
" cs.length w = 0 → w = 1",
" w = 1",
" cs.wordProd ω = 1",
... |
import Mathlib.MeasureTheory.Measure.Restrict
#align_import measure_theory.measure.mutually_singular from "leanprover-community/mathlib"@"70a4f2197832bceab57d7f41379b2592d1110570"
open Set
open MeasureTheory NNReal ENNReal
namespace MeasureTheory
namespace Measure
variable {α : Type*} {m0 : MeasurableSpace α}... | Mathlib/MeasureTheory/Measure/MutuallySingular.lean | 48 | 52 | theorem mk {s t : Set α} (hs : μ s = 0) (ht : ν t = 0) (hst : univ ⊆ s ∪ t) :
MutuallySingular μ ν := by |
use toMeasurable μ s, measurableSet_toMeasurable _ _, (measure_toMeasurable _).trans hs
refine measure_mono_null (fun x hx => (hst trivial).resolve_left fun hxs => hx ?_) ht
exact subset_toMeasurable _ _ hxs
| [
" μ ⟂ₘ ν",
" ν (toMeasurable μ s)ᶜ = 0",
" x ∈ toMeasurable μ s"
] | [] |
import Mathlib.Data.List.Range
import Mathlib.Algebra.Order.Ring.Nat
variable {α : Type*}
namespace List
@[simp]
theorem length_iterate (f : α → α) (a : α) (n : ℕ) : length (iterate f a n) = n := by
induction n generalizing a <;> simp [*]
@[simp]
theorem iterate_eq_nil {f : α → α} {a : α} {n : ℕ} : iterate f ... | Mathlib/Data/List/Iterate.lean | 48 | 52 | theorem iterate_add (f : α → α) (a : α) (m n : ℕ) :
iterate f a (m + n) = iterate f a m ++ iterate f (f^[m] a) n := by |
induction m generalizing a with
| zero => simp
| succ n ih => rw [iterate, add_right_comm, iterate, ih, Nat.iterate, cons_append]
| [
" (iterate f a n).length = n",
" (iterate f a 0).length = 0",
" (iterate f a (n✝ + 1)).length = n✝ + 1",
" iterate f a n = [] ↔ n = 0",
" (iterate f a (n + 1)).get? (i + 1) = some (f^[i + 1] a)",
" i < n",
" ↑i < n",
" b ∈ iterate f a n ↔ ∃ m < n, b = f^[m] a",
" map (fun x => f^[x] a) (range n) = i... | [
" (iterate f a n).length = n",
" (iterate f a 0).length = 0",
" (iterate f a (n✝ + 1)).length = n✝ + 1",
" iterate f a n = [] ↔ n = 0",
" (iterate f a (n + 1)).get? (i + 1) = some (f^[i + 1] a)",
" i < n",
" ↑i < n",
" b ∈ iterate f a n ↔ ∃ m < n, b = f^[m] a",
" map (fun x => f^[x] a) (range n) = i... |
import Mathlib.Control.Bitraversable.Basic
#align_import control.bitraversable.lemmas from "leanprover-community/mathlib"@"58581d0fe523063f5651df0619be2bf65012a94a"
universe u
variable {t : Type u → Type u → Type u} [Bitraversable t]
variable {β : Type u}
namespace Bitraversable
open Functor LawfulApplicative
... | Mathlib/Control/Bitraversable/Lemmas.lean | 110 | 112 | theorem tfst_eq_fst_id {α α' β} (f : α → α') (x : t α β) :
tfst (F := Id) (pure ∘ f) x = pure (fst f x) := by |
apply bitraverse_eq_bimap_id
| [
" Comp.mk (tfst f' <$> tfst f x) = tfst (Comp.mk ∘ map f' ∘ f) x",
" bitraverse (Comp.mk ∘ map f' ∘ f) (Comp.mk ∘ map pure ∘ pure) x = tfst (Comp.mk ∘ map f' ∘ f) x",
" Comp.mk (tfst f <$> tsnd f' x) = bitraverse (Comp.mk ∘ pure ∘ f) (Comp.mk ∘ map pure ∘ f') x",
" bitraverse (Comp.mk ∘ map f ∘ pure) (Comp.mk... | [
" Comp.mk (tfst f' <$> tfst f x) = tfst (Comp.mk ∘ map f' ∘ f) x",
" bitraverse (Comp.mk ∘ map f' ∘ f) (Comp.mk ∘ map pure ∘ pure) x = tfst (Comp.mk ∘ map f' ∘ f) x",
" Comp.mk (tfst f <$> tsnd f' x) = bitraverse (Comp.mk ∘ pure ∘ f) (Comp.mk ∘ map pure ∘ f') x",
" bitraverse (Comp.mk ∘ map f ∘ pure) (Comp.mk... |
import Mathlib.Algebra.Polynomial.Derivative
import Mathlib.Tactic.LinearCombination
#align_import ring_theory.polynomial.chebyshev from "leanprover-community/mathlib"@"d774451114d6045faeb6751c396bea1eb9058946"
namespace Polynomial.Chebyshev
set_option linter.uppercaseLean3 false -- `T` `U` `X`
open Polynomial
v... | Mathlib/RingTheory/Polynomial/Chebyshev.lean | 96 | 97 | theorem T_sub_one (n : ℤ) : T R (n - 1) = 2 * X * T R n - T R (n + 1) := by |
linear_combination (norm := ring_nf) T_add_two R (n - 1)
| [
" motive (Int.negSucc n)",
" T R (-↑(k + 1) + 2) = 2 * X * T R (-↑(k + 1) + 1) - T R (-↑(k + 1))",
" T R (-↑(k + 1) + 2) - (2 * X * T R (-↑(k + 1) + 1) - T R (-↑(k + 1))) -\n (T R (Int.negSucc k) - (2 * X * T R (-↑k) - T R (-↑k + 1))) =\n 0",
" T R (-1 + -↑k + 2) - (2 * X * T R (-↑k) - T R (-1 + -↑k))... | [
" motive (Int.negSucc n)",
" T R (-↑(k + 1) + 2) = 2 * X * T R (-↑(k + 1) + 1) - T R (-↑(k + 1))",
" T R (-↑(k + 1) + 2) - (2 * X * T R (-↑(k + 1) + 1) - T R (-↑(k + 1))) -\n (T R (Int.negSucc k) - (2 * X * T R (-↑k) - T R (-↑k + 1))) =\n 0",
" T R (-1 + -↑k + 2) - (2 * X * T R (-↑k) - T R (-1 + -↑k))... |
import Mathlib.Analysis.SpecialFunctions.ImproperIntegrals
import Mathlib.Analysis.Calculus.ParametricIntegral
import Mathlib.MeasureTheory.Measure.Haar.NormedSpace
#align_import analysis.mellin_transform from "leanprover-community/mathlib"@"917c3c072e487b3cccdbfeff17e75b40e45f66cb"
open MeasureTheory Set Filter A... | Mathlib/Analysis/MellinTransform.lean | 53 | 56 | theorem MellinConvergent.cpow_smul {f : ℝ → E} {s a : ℂ} :
MellinConvergent (fun t => (t : ℂ) ^ a • f t) s ↔ MellinConvergent f (s + a) := by |
refine integrableOn_congr_fun (fun t ht => ?_) measurableSet_Ioi
simp_rw [← sub_add_eq_add_sub, cpow_add _ _ (ofReal_ne_zero.2 <| ne_of_gt ht), mul_smul]
| [
" MellinConvergent (fun t => c • f t) s",
" MellinConvergent (fun t => ↑t ^ a • f t) s ↔ MellinConvergent f (s + a)",
" ↑t ^ (s - 1) • (fun t => ↑t ^ a • f t) t = ↑t ^ (s + a - 1) • f t"
] | [
" MellinConvergent (fun t => c • f t) s"
] |
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Data.List.MinMax
import Mathlib.Algebra.Tropical.Basic
import Mathlib.Order.ConditionallyCompleteLattice.Finset
#align_import algebra.tropical.big_operators from "leanprover-community/mathlib"@"d6fad0e5bf2d6f48da9175d25c3dc5706b3834ce"
variable {R S :... | Mathlib/Algebra/Tropical/BigOperators.lean | 70 | 74 | theorem untrop_prod [AddCommMonoid R] (s : Finset S) (f : S → Tropical R) :
untrop (∏ i ∈ s, f i) = ∑ i ∈ s, untrop (f i) := by |
convert Multiset.untrop_prod (s.val.map f)
simp only [Multiset.map_map, Function.comp_apply]
rfl
| [
" trop l.sum = (map trop l).prod",
" trop [].sum = (map trop []).prod",
" trop (hd :: tl).sum = (map trop (hd :: tl)).prod",
" ∀ (a : List R), trop (sum ⟦a⟧) = (map trop ⟦a⟧).prod",
" trop (∑ i ∈ s, f i) = ∏ i ∈ s, trop (f i)",
" ∏ i ∈ s, trop (f i) = (Multiset.map trop (Multiset.map f s.val)).prod",
" ... | [
" trop l.sum = (map trop l).prod",
" trop [].sum = (map trop []).prod",
" trop (hd :: tl).sum = (map trop (hd :: tl)).prod",
" ∀ (a : List R), trop (sum ⟦a⟧) = (map trop ⟦a⟧).prod",
" trop (∑ i ∈ s, f i) = ∏ i ∈ s, trop (f i)",
" ∏ i ∈ s, trop (f i) = (Multiset.map trop (Multiset.map f s.val)).prod",
" ... |
import Mathlib.Geometry.Euclidean.Inversion.Basic
import Mathlib.Geometry.Euclidean.PerpBisector
open Metric Function AffineMap Set AffineSubspace
open scoped Topology
variable {V P : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P]
[NormedAddTorsor V P] {c x y : P} {R : ℝ}
namespace Euclid... | Mathlib/Geometry/Euclidean/Inversion/ImageHyperplane.lean | 66 | 71 | theorem preimage_inversion_sphere_dist_center (hR : R ≠ 0) (hy : y ≠ c) :
inversion c R ⁻¹' sphere y (dist y c) =
insert c (perpBisector c (inversion c R y) : Set P) := by |
ext x
rcases eq_or_ne x c with rfl | hx; · simp [dist_comm]
rw [mem_preimage, mem_sphere, ← inversion_mem_perpBisector_inversion_iff hR] <;> simp [*]
| [
" inversion c R x ∈ perpBisector c (inversion c R y) ↔ dist x y = dist y c",
" R ^ 2 / dist x c = R ^ 2 / (dist x c * dist y c) * dist x y ↔ dist x y = dist y c",
" inversion c R x ∈ perpBisector c (inversion c R y) ↔ dist x y = dist y c ∧ x ≠ c",
" inversion x R x ∈ perpBisector x (inversion x R y) ↔ dist x ... | [
" inversion c R x ∈ perpBisector c (inversion c R y) ↔ dist x y = dist y c",
" R ^ 2 / dist x c = R ^ 2 / (dist x c * dist y c) * dist x y ↔ dist x y = dist y c",
" inversion c R x ∈ perpBisector c (inversion c R y) ↔ dist x y = dist y c ∧ x ≠ c",
" inversion x R x ∈ perpBisector x (inversion x R y) ↔ dist x ... |
import Mathlib.Algebra.Group.Commute.Basic
import Mathlib.GroupTheory.GroupAction.Basic
import Mathlib.Dynamics.PeriodicPts
import Mathlib.Data.Set.Pointwise.SMul
namespace MulAction
open Pointwise
variable {α : Type*}
variable {G : Type*} [Group G] [MulAction G α]
variable {M : Type*} [Monoid M] [MulAction M α]
... | Mathlib/GroupTheory/GroupAction/FixedPoints.lean | 238 | 240 | theorem fixedBy_eq_univ_iff_eq_one {m : M} : fixedBy α m = Set.univ ↔ m = 1 := by |
rw [← (smul_left_injective' (M := M) (α := α)).eq_iff, Set.eq_univ_iff_forall]
simp_rw [Function.funext_iff, one_smul, mem_fixedBy]
| [
" fixedBy α m = Set.univ ↔ m = 1",
" (∀ (x : α), x ∈ fixedBy α m) ↔ (fun x => m • x) = fun x => 1 • x"
] | [] |
import Mathlib.Data.List.Chain
import Mathlib.Data.List.Enum
import Mathlib.Data.List.Nodup
import Mathlib.Data.List.Pairwise
import Mathlib.Data.List.Zip
#align_import data.list.range from "leanprover-community/mathlib"@"7b78d1776212a91ecc94cf601f83bdcc46b04213"
set_option autoImplicit true
universe u
open Nat... | Mathlib/Data/List/Range.lean | 87 | 90 | theorem take_range (m n : ℕ) : take m (range n) = range (min m n) := by |
apply List.ext_get
· simp
· simp (config := { contextual := true }) [← get_take, Nat.lt_min]
| [
" (range' n m).nthLe i H = n + i",
" Pairwise (fun x x_1 => x < x_1) (range n)",
" take m (range n) = range (min m n)",
" (take m (range n)).length = (range (min m n)).length",
" ∀ (n_1 : ℕ) (h₁ : n_1 < (take m (range n)).length) (h₂ : n_1 < (range (min m n)).length),\n (take m (range n)).get ⟨n_1, h₁⟩ =... | [
" (range' n m).nthLe i H = n + i",
" Pairwise (fun x x_1 => x < x_1) (range n)"
] |
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 | 84 | 89 | theorem ContDiffAt.real_of_complex {n : ℕ∞} (h : ContDiffAt ℂ n e z) :
ContDiffAt ℝ n (fun x : ℝ => (e x).re) z := by |
have A : ContDiffAt ℝ n ((↑) : ℝ → ℂ) z := ofRealCLM.contDiff.contDiffAt
have B : ContDiffAt ℝ n e z := h.restrict_scalars ℝ
have C : ContDiffAt ℝ n re (e z) := reCLM.contDiff.contDiffAt
exact C.comp z (B.comp z A)
| [
" 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.Algebra.MonoidAlgebra.Basic
#align_import algebra.monoid_algebra.division from "leanprover-community/mathlib"@"72c366d0475675f1309d3027d3d7d47ee4423951"
variable {k G : Type*} [Semiring k]
namespace AddMonoidAlgebra
section
variable [AddCancelCommMonoid G]
noncomputable def divOf (x : k[G]) (g... | Mathlib/Algebra/MonoidAlgebra/Division.lean | 112 | 117 | theorem mul_of'_divOf (x : k[G]) (a : G) : x * of' k G a /ᵒᶠ a = x := by |
refine Finsupp.ext fun _ => ?_ -- Porting note: `ext` doesn't work
rw [AddMonoidAlgebra.divOf_apply, of'_apply, mul_single_apply_aux, mul_one]
intro c
rw [add_comm]
exact add_right_inj _
| [
" x /ᵒᶠ 0 = x",
" (x /ᵒᶠ 0) x✝ = x x✝",
" x /ᵒᶠ (a + b) = x /ᵒᶠ a /ᵒᶠ b",
" (x /ᵒᶠ (a + b)) x✝ = (x /ᵒᶠ a /ᵒᶠ b) x✝",
" of' k G a * x /ᵒᶠ a = x",
" (of' k G a * x /ᵒᶠ a) x✝ = x x✝",
" ∀ (a_1 : G), a + a_1 = a + x✝ ↔ a_1 = x✝",
" a + c = a + x✝ ↔ c = x✝",
" x * of' k G a /ᵒᶠ a = x",
" (x * of' k G ... | [
" x /ᵒᶠ 0 = x",
" (x /ᵒᶠ 0) x✝ = x x✝",
" x /ᵒᶠ (a + b) = x /ᵒᶠ a /ᵒᶠ b",
" (x /ᵒᶠ (a + b)) x✝ = (x /ᵒᶠ a /ᵒᶠ b) x✝",
" of' k G a * x /ᵒᶠ a = x",
" (of' k G a * x /ᵒᶠ a) x✝ = x x✝",
" ∀ (a_1 : G), a + a_1 = a + x✝ ↔ a_1 = x✝",
" a + c = a + x✝ ↔ c = x✝"
] |
import Mathlib.Analysis.Calculus.FormalMultilinearSeries
import Mathlib.Analysis.SpecificLimits.Normed
import Mathlib.Logic.Equiv.Fin
import Mathlib.Topology.Algebra.InfiniteSum.Module
#align_import analysis.analytic.basic from "leanprover-community/mathlib"@"32253a1a1071173b33dc7d6a218cf722c6feb514"
noncomputable... | Mathlib/Analysis/Analytic/Basic.lean | 102 | 105 | theorem partialSum_continuous (p : FormalMultilinearSeries 𝕜 E F) (n : ℕ) :
Continuous (p.partialSum n) := by |
unfold partialSum -- Porting note: added
continuity
| [
" Continuous (p.partialSum n)",
" Continuous fun x => ∑ k ∈ Finset.range n, (p k) fun x_1 => x"
] | [] |
import Mathlib.LinearAlgebra.Dimension.Finrank
import Mathlib.LinearAlgebra.InvariantBasisNumber
#align_import linear_algebra.dimension from "leanprover-community/mathlib"@"47a5f8186becdbc826190ced4312f8199f9db6a5"
noncomputable section
universe u v w w'
variable {R : Type u} {M : Type v} [Ring R] [AddCommGroup... | Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean | 140 | 164 | theorem Basis.le_span {J : Set M} (v : Basis ι R M) (hJ : span R J = ⊤) : #(range v) ≤ #J := by |
haveI := nontrivial_of_invariantBasisNumber R
cases fintypeOrInfinite J
· rw [← Cardinal.lift_le, Cardinal.mk_range_eq_of_injective v.injective, Cardinal.mk_fintype J]
convert Cardinal.lift_le.{v}.2 (basis_le_span' v hJ)
simp
· let S : J → Set ι := fun j => ↑(v.repr j).support
let S' : J → Set M :=... | [
" Fintype.card ι ≤ Fintype.card ↑w",
" (↑w →₀ R) →ₗ[R] ι →₀ R",
" Surjective ⇑(↑b.repr ∘ₗ Finsupp.total (↑w) M R Subtype.val)",
" Surjective ⇑↑b.repr",
" Surjective fun x => (Finsupp.total (↑w) M R Subtype.val) x",
" span R (range Subtype.val) = ⊤",
" #ι ≤ ↑(Fintype.card ↑w)",
" ↑(Fintype.card ι) ≤ ↑(... | [
" Fintype.card ι ≤ Fintype.card ↑w",
" (↑w →₀ R) →ₗ[R] ι →₀ R",
" Surjective ⇑(↑b.repr ∘ₗ Finsupp.total (↑w) M R Subtype.val)",
" Surjective ⇑↑b.repr",
" Surjective fun x => (Finsupp.total (↑w) M R Subtype.val) x",
" span R (range Subtype.val) = ⊤",
" #ι ≤ ↑(Fintype.card ↑w)",
" ↑(Fintype.card ι) ≤ ↑(... |
import Mathlib.Algebra.Algebra.Tower
import Mathlib.Analysis.LocallyConvex.WithSeminorms
import Mathlib.Topology.Algebra.Module.StrongTopology
import Mathlib.Analysis.NormedSpace.LinearIsometry
import Mathlib.Analysis.NormedSpace.ContinuousLinearMap
import Mathlib.Tactic.SuppressCompilation
#align_import analysis.nor... | Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean | 54 | 57 | theorem norm_image_of_norm_zero [SemilinearMapClass 𝓕 σ₁₂ E F] (f : 𝓕) (hf : Continuous f) {x : E}
(hx : ‖x‖ = 0) : ‖f x‖ = 0 := by |
rw [← mem_closure_zero_iff_norm, ← specializes_iff_mem_closure, ← map_zero f] at *
exact hx.map hf
| [
" ‖f x‖ = 0",
" f 0 ⤳ f x"
] | [] |
import Mathlib.LinearAlgebra.Quotient
#align_import linear_algebra.isomorphisms from "leanprover-community/mathlib"@"2738d2ca56cbc63be80c3bd48e9ed90ad94e947d"
universe u v
variable {R M M₂ M₃ : Type*}
variable [Ring R] [AddCommGroup M] [AddCommGroup M₂] [AddCommGroup M₃]
variable [Module R M] [Module R M₂] [Modul... | Mathlib/LinearAlgebra/Isomorphisms.lean | 88 | 93 | theorem quotientInfEquivSupQuotient_surjective (p p' : Submodule R M) :
Function.Surjective (quotientInfToSupQuotient p p') := by |
rw [← range_eq_top, quotientInfToSupQuotient, range_liftQ, eq_top_iff']
rintro ⟨x, hx⟩; rcases mem_sup.1 hx with ⟨y, hy, z, hz, rfl⟩
use ⟨y, hy⟩; apply (Submodule.Quotient.eq _).2
simp only [mem_comap, map_sub, coeSubtype, coe_inclusion, sub_add_cancel_left, neg_mem_iff, hz]
| [
" comap p.subtype (p ⊓ p') ≤ ker (subToSupQuotient p p')",
" comap p.subtype (p ⊓ p') ≤ comap p.subtype ((p ⊔ p') ⊓ p')",
" Function.Injective ⇑(quotientInfToSupQuotient p p')",
" ker (subToSupQuotient p p') ≤ comap p.subtype (p ⊓ p')",
" comap (inclusion ⋯) (comap (p ⊔ p').subtype p') ≤ comap p.subtype (p ... | [
" comap p.subtype (p ⊓ p') ≤ ker (subToSupQuotient p p')",
" comap p.subtype (p ⊓ p') ≤ comap p.subtype ((p ⊔ p') ⊓ p')",
" Function.Injective ⇑(quotientInfToSupQuotient p p')",
" ker (subToSupQuotient p p') ≤ comap p.subtype (p ⊓ p')",
" comap (inclusion ⋯) (comap (p ⊔ p').subtype p') ≤ comap p.subtype (p ... |
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 | 113 | 118 | theorem map_dualTensorHom (f : Module.Dual R M) (p : P) (g : Module.Dual R N) (q : Q) :
TensorProduct.map (dualTensorHom R M P (f ⊗ₜ[R] p)) (dualTensorHom R N Q (g ⊗ₜ[R] q)) =
dualTensorHom R (M ⊗[R] N) (P ⊗[R] Q) (dualDistrib R M N (f ⊗ₜ g) ⊗ₜ[R] p ⊗ₜ[R] q) := by |
ext m n
simp only [compr₂_apply, mk_apply, map_tmul, dualTensorHom_apply, dualDistrib_apply, ←
smul_tmul_smul]
| [
" 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.Algebra.Group.Basic
import Mathlib.Algebra.Group.Nat
import Mathlib.Init.Data.Nat.Lemmas
#align_import data.nat.psub from "leanprover-community/mathlib"@"70d50ecfd4900dd6d328da39ab7ebd516abe4025"
namespace Nat
def ppred : ℕ → Option ℕ
| 0 => none
| n + 1 => some n
#align nat.ppred Nat.ppred
@... | Mathlib/Data/Nat/PSub.lean | 85 | 93 | theorem psub_eq_none {m n : ℕ} : psub m n = none ↔ m < n := by |
cases s : psub m n <;> simp [eq_comm]
· show m < n
refine lt_of_not_ge fun h => ?_
cases' le.dest h with k e
injection s.symm.trans (psub_eq_some.2 <| (add_comm _ _).trans e)
· show n ≤ m
rw [← psub_eq_some.1 s]
apply Nat.le_add_left
| [
" n.pred = n.ppred.getD 0",
" pred 0 = (ppred 0).getD 0",
" (n✝ + 1).pred = (n✝ + 1).ppred.getD 0",
" (m - n).ppred.getD 0 = (m.psub (n + 1)).getD 0",
" ((m.psub n).getD 0).ppred.getD 0 = (m.psub n >>= ppred).getD 0",
" (none.getD 0).ppred.getD 0 = (none >>= ppred).getD 0",
" ((some val✝).getD 0).ppred.... | [
" n.pred = n.ppred.getD 0",
" pred 0 = (ppred 0).getD 0",
" (n✝ + 1).pred = (n✝ + 1).ppred.getD 0",
" (m - n).ppred.getD 0 = (m.psub (n + 1)).getD 0",
" ((m.psub n).getD 0).ppred.getD 0 = (m.psub n >>= ppred).getD 0",
" (none.getD 0).ppred.getD 0 = (none >>= ppred).getD 0",
" ((some val✝).getD 0).ppred.... |
import Mathlib.SetTheory.Game.State
#align_import set_theory.game.domineering from "leanprover-community/mathlib"@"b134b2f5cf6dd25d4bbfd3c498b6e36c11a17225"
namespace SetTheory
namespace PGame
namespace Domineering
open Function
@[simps!]
def shiftUp : ℤ × ℤ ≃ ℤ × ℤ :=
(Equiv.refl ℤ).prodCongr (Equiv.addRig... | Mathlib/SetTheory/Game/Domineering.lean | 101 | 106 | theorem card_of_mem_right {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) : 2 ≤ Finset.card b := by |
have w₁ : m ∈ b := (Finset.mem_inter.1 h).1
have w₂ := fst_pred_mem_erase_of_mem_right h
have i₁ := Finset.card_erase_lt_of_mem w₁
have i₂ := Nat.lt_of_le_of_lt (Nat.zero_le _) (Finset.card_erase_lt_of_mem w₂)
exact Nat.lt_of_le_of_lt i₂ i₁
| [
" (m.1 - 1, m.2) ∈ Finset.erase b m",
" (m.1 - 1, m.2) ≠ m",
" (m.1, m.2 - 1) ∈ Finset.erase b m",
" (m.1, m.2 - 1) ≠ m",
" 2 ≤ Finset.card b"
] | [
" (m.1 - 1, m.2) ∈ Finset.erase b m",
" (m.1 - 1, m.2) ≠ m",
" (m.1, m.2 - 1) ∈ Finset.erase b m",
" (m.1, m.2 - 1) ≠ m",
" 2 ≤ Finset.card b"
] |
import Mathlib.CategoryTheory.Elements
import Mathlib.CategoryTheory.IsConnected
import Mathlib.CategoryTheory.SingleObj
import Mathlib.GroupTheory.GroupAction.Quotient
import Mathlib.GroupTheory.SemidirectProduct
#align_import category_theory.action from "leanprover-community/mathlib"@"aa812bd12a4dbbd2c129b38205f222... | Mathlib/CategoryTheory/Action.lean | 89 | 89 | theorem back_coe (x : ActionCategory M X) : ↑x.back = x := by | cases x; rfl
| [
" Category.{?u.1368, u} (ActionCategory M X)",
" Category.{?u.1368, u} (actionAsFunctor M X).Elements",
" ⟨(), x.back⟩ = x",
" ⟨(), ActionCategory.back ⟨fst✝, snd✝⟩⟩ = ⟨fst✝, snd✝⟩"
] | [
" Category.{?u.1368, u} (ActionCategory M X)",
" Category.{?u.1368, u} (actionAsFunctor M X).Elements"
] |
import Mathlib.Algebra.Algebra.Subalgebra.Operations
import Mathlib.Algebra.Ring.Fin
import Mathlib.RingTheory.Ideal.Quotient
#align_import ring_theory.ideal.quotient_operations from "leanprover-community/mathlib"@"b88d81c84530450a8989e918608e5960f015e6c8"
universe u v w
namespace Ideal
open Function RingHom
var... | Mathlib/RingTheory/Ideal/QuotientOperations.lean | 131 | 133 | theorem mk_ker {I : Ideal R} : ker (Quotient.mk I) = I := by |
ext
rw [ker, mem_comap, Submodule.mem_bot, Quotient.eq_zero_iff_mem]
| [
" ker (Quotient.mk I) = I",
" x✝ ∈ ker (Quotient.mk I) ↔ x✝ ∈ I"
] | [] |
import Mathlib.Analysis.SpecialFunctions.Gamma.Beta
import Mathlib.NumberTheory.LSeries.HurwitzZeta
import Mathlib.Analysis.Complex.RemovableSingularity
import Mathlib.Analysis.PSeriesComplex
#align_import number_theory.zeta_function from "leanprover-community/mathlib"@"57f9349f2fe19d2de7207e99b0341808d977cdcf"
o... | Mathlib/NumberTheory/LSeries/RiemannZeta.lean | 103 | 105 | theorem completedRiemannZeta₀_one_sub (s : ℂ) :
completedRiemannZeta₀ (1 - s) = completedRiemannZeta₀ s := by |
rw [← completedHurwitzZetaEven₀_zero, ← completedCosZeta₀_zero, completedHurwitzZetaEven₀_one_sub]
| [
" completedCosZeta 0 s = completedRiemannZeta s",
" completedCosZeta₀ 0 s = completedRiemannZeta₀ s",
" completedRiemannZeta s = completedRiemannZeta₀ s - 1 / s - 1 / (1 - s)",
" completedRiemannZeta₀ (1 - s) = completedRiemannZeta₀ s"
] | [
" completedCosZeta 0 s = completedRiemannZeta s",
" completedCosZeta₀ 0 s = completedRiemannZeta₀ s",
" completedRiemannZeta s = completedRiemannZeta₀ s - 1 / s - 1 / (1 - s)"
] |
import Mathlib.CategoryTheory.Idempotents.Basic
import Mathlib.CategoryTheory.Preadditive.AdditiveFunctor
import Mathlib.CategoryTheory.Equivalence
#align_import category_theory.idempotents.karoubi from "leanprover-community/mathlib"@"200eda15d8ff5669854ff6bcc10aaf37cb70498f"
noncomputable section
open CategoryT... | Mathlib/CategoryTheory/Idempotents/Karoubi.lean | 60 | 66 | theorem ext {P Q : Karoubi C} (h_X : P.X = Q.X) (h_p : P.p ≫ eqToHom h_X = eqToHom h_X ≫ Q.p) :
P = Q := by |
cases P
cases Q
dsimp at h_X h_p
subst h_X
simpa only [mk.injEq, heq_eq_eq, true_and, eqToHom_refl, comp_id, id_comp] using h_p
| [
" P = Q",
" { X := X✝, p := p✝, idem := idem✝ } = Q",
" { X := X✝¹, p := p✝¹, idem := idem✝¹ } = { X := X✝, p := p✝, idem := idem✝ }",
" { X := X✝, p := p✝¹, idem := idem✝¹ } = { X := X✝, p := p✝, idem := idem✝ }"
] | [] |
import Mathlib.Data.Fintype.Option
import Mathlib.Topology.Separation
import Mathlib.Topology.Sets.Opens
#align_import topology.alexandroff from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Set Filter Topology
variable {X : Type*}
def OnePoint (X : Type*) :=
Option X
#ali... | Mathlib/Topology/Compactification/OnePoint.lean | 152 | 153 | theorem not_mem_range_coe_iff {x : OnePoint X} : x ∉ range some ↔ x = ∞ := by |
rw [← mem_compl_iff, compl_range_coe, mem_singleton_iff]
| [
" (some '' s)ᶜ = some '' sᶜ ∪ {∞}",
" x ≠ ∞ ↔ ∃ y, ↑y = x",
" ∞ ≠ ∞ ↔ ∃ y, ↑y = ∞",
" ↑x✝ ≠ ∞ ↔ ∃ y, ↑y = ↑x✝",
" x ∉ range some ↔ x = ∞"
] | [
" (some '' s)ᶜ = some '' sᶜ ∪ {∞}",
" x ≠ ∞ ↔ ∃ y, ↑y = x",
" ∞ ≠ ∞ ↔ ∃ y, ↑y = ∞",
" ↑x✝ ≠ ∞ ↔ ∃ y, ↑y = ↑x✝"
] |
import Mathlib.Order.Lattice
import Mathlib.Data.List.Sort
import Mathlib.Logic.Equiv.Fin
import Mathlib.Logic.Equiv.Functor
import Mathlib.Data.Fintype.Card
import Mathlib.Order.RelSeries
#align_import order.jordan_holder from "leanprover-community/mathlib"@"91288e351d51b3f0748f0a38faa7613fb0ae2ada"
universe u
... | Mathlib/Order/JordanHolder.lean | 102 | 106 | theorem isMaximal_inf_right_of_isMaximal_sup {x y : X} (hxz : IsMaximal x (x ⊔ y))
(hyz : IsMaximal y (x ⊔ y)) : IsMaximal (x ⊓ y) y := by |
rw [inf_comm]
rw [sup_comm] at hxz hyz
exact isMaximal_inf_left_of_isMaximal_sup hyz hxz
| [
" IsMaximal (x ⊓ y) y",
" IsMaximal (y ⊓ x) y"
] | [] |
import Mathlib.CategoryTheory.Subobject.Limits
#align_import algebra.homology.image_to_kernel from "leanprover-community/mathlib"@"618ea3d5c99240cd7000d8376924906a148bf9ff"
universe v u w
open CategoryTheory CategoryTheory.Limits
variable {ι : Type*}
variable {V : Type u} [Category.{v} V] [HasZeroMorphisms V]
o... | Mathlib/Algebra/Homology/ImageToKernel.lean | 95 | 98 | theorem imageToKernel_zero_left [HasKernels V] [HasZeroObject V] {w} :
imageToKernel (0 : A ⟶ B) g w = 0 := by |
ext
simp
| [
" kernel.lift g f w ≫ kernel.ι g = f",
" Mono (imageToKernel f g w)",
" Mono ((imageSubobject f).ofLE (kernelSubobject g) ⋯)",
" imageToKernel f g w ≫ (kernelSubobject g).arrow = (imageSubobject f).arrow",
" (kernelSubobject g).arrow ((imageToKernel f g w) x) = (imageSubobject f).arrow x",
" factorThruIma... | [
" kernel.lift g f w ≫ kernel.ι g = f",
" Mono (imageToKernel f g w)",
" Mono ((imageSubobject f).ofLE (kernelSubobject g) ⋯)",
" imageToKernel f g w ≫ (kernelSubobject g).arrow = (imageSubobject f).arrow",
" (kernelSubobject g).arrow ((imageToKernel f g w) x) = (imageSubobject f).arrow x",
" factorThruIma... |
import Mathlib.Algebra.CharP.Two
import Mathlib.Data.Nat.Factorization.Basic
import Mathlib.Data.Nat.Periodic
import Mathlib.Data.ZMod.Basic
import Mathlib.Tactic.Monotonicity
#align_import data.nat.totient from "leanprover-community/mathlib"@"5cc2dfdd3e92f340411acea4427d701dc7ed26f8"
open Finset
namespace Nat
... | Mathlib/Data/Nat/Totient.lean | 129 | 135 | theorem totient_even {n : ℕ} (hn : 2 < n) : Even n.totient := by |
haveI : Fact (1 < n) := ⟨one_lt_two.trans hn⟩
haveI : NeZero n := NeZero.of_gt hn
suffices 2 = orderOf (-1 : (ZMod n)ˣ) by
rw [← ZMod.card_units_eq_totient, even_iff_two_dvd, this]
exact orderOf_dvd_card
rw [← orderOf_units, Units.coe_neg_one, orderOf_neg_one, ringChar.eq (ZMod n) n, if_neg hn.ne']
| [
" φ n = Nat.card ↑{m | m < n ∧ n.Coprime m}",
" ↑m ∈ filter n.Coprime (range n)",
" ↑m ∈ {m | m < n ∧ n.Coprime m}",
" (fun m => ⟨↑m, ⋯⟩) ((fun m => ⟨↑m, ⋯⟩) m) = m",
" 0 ∈ range n ∧ ¬n.Coprime 0",
" φ 0 = 0 ↔ 0 = 0",
" (n + 1).gcd (1 % (n + 1)) = 1",
" φ (n + 1) = 0 ↔ n + 1 = 0",
" 0 < φ n ↔ 0 < n"... | [
" φ n = Nat.card ↑{m | m < n ∧ n.Coprime m}",
" ↑m ∈ filter n.Coprime (range n)",
" ↑m ∈ {m | m < n ∧ n.Coprime m}",
" (fun m => ⟨↑m, ⋯⟩) ((fun m => ⟨↑m, ⋯⟩) m) = m",
" 0 ∈ range n ∧ ¬n.Coprime 0",
" φ 0 = 0 ↔ 0 = 0",
" (n + 1).gcd (1 % (n + 1)) = 1",
" φ (n + 1) = 0 ↔ n + 1 = 0",
" 0 < φ n ↔ 0 < n"... |
import Mathlib.Combinatorics.SimpleGraph.Connectivity
import Mathlib.Tactic.Linarith
#align_import combinatorics.simple_graph.acyclic from "leanprover-community/mathlib"@"b07688016d62f81d14508ff339ea3415558d6353"
universe u v
namespace SimpleGraph
open Walk
variable {V : Type u} (G : SimpleGraph V)
def IsAcy... | Mathlib/Combinatorics/SimpleGraph/Acyclic.lean | 134 | 154 | theorem isTree_iff_existsUnique_path :
G.IsTree ↔ Nonempty V ∧ ∀ v w : V, ∃! p : G.Walk v w, p.IsPath := by |
classical
rw [isTree_iff, isAcyclic_iff_path_unique]
constructor
· rintro ⟨hc, hu⟩
refine ⟨hc.nonempty, ?_⟩
intro v w
let q := (hc v w).some.toPath
use q
simp only [true_and_iff, Path.isPath]
intro p hp
specialize hu ⟨p, hp⟩ q
exact Subtype.ext_iff.mp hu
· rintro ⟨hV, h⟩
r... | [
" G.IsAcyclic ↔ ∀ ⦃v w : V⦄, G.Adj v w → G.IsBridge s(v, w)",
" G.IsAcyclic ↔ ∀ ⦃v w : V⦄, G.Adj v w → G.Adj v w ∧ ∀ ⦃u : V⦄ (p : G.Walk u u), p.IsCycle → s(v, w) ∉ p.edges",
" G.IsAcyclic → ∀ ⦃v w : V⦄, G.Adj v w → G.Adj v w ∧ ∀ ⦃u : V⦄ (p : G.Walk u u), p.IsCycle → s(v, w) ∉ p.edges",
" G.Adj v w ∧ ∀ ⦃u : V... | [
" G.IsAcyclic ↔ ∀ ⦃v w : V⦄, G.Adj v w → G.IsBridge s(v, w)",
" G.IsAcyclic ↔ ∀ ⦃v w : V⦄, G.Adj v w → G.Adj v w ∧ ∀ ⦃u : V⦄ (p : G.Walk u u), p.IsCycle → s(v, w) ∉ p.edges",
" G.IsAcyclic → ∀ ⦃v w : V⦄, G.Adj v w → G.Adj v w ∧ ∀ ⦃u : V⦄ (p : G.Walk u u), p.IsCycle → s(v, w) ∉ p.edges",
" G.Adj v w ∧ ∀ ⦃u : V... |
import Mathlib.Combinatorics.SimpleGraph.Subgraph
import Mathlib.Data.List.Rotate
#align_import combinatorics.simple_graph.connectivity from "leanprover-community/mathlib"@"b99e2d58a5e6861833fa8de11e51a81144258db4"
open Function
universe u v w
namespace SimpleGraph
variable {V : Type u} {V' : Type v} {V'' : Typ... | Mathlib/Combinatorics/SimpleGraph/Connectivity.lean | 141 | 143 | theorem copy_nil {u u'} (hu : u = u') : (Walk.nil : G.Walk u u).copy hu hu = Walk.nil := by |
subst_vars
rfl
| [
" (p.copy hu hv).copy hu' hv' = p.copy ⋯ ⋯",
" (p.copy ⋯ ⋯).copy ⋯ ⋯ = p.copy ⋯ ⋯",
" nil.copy hu hu = nil",
" nil.copy ⋯ ⋯ = nil"
] | [
" (p.copy hu hv).copy hu' hv' = p.copy ⋯ ⋯",
" (p.copy ⋯ ⋯).copy ⋯ ⋯ = p.copy ⋯ ⋯"
] |
import Mathlib.Algebra.Polynomial.Basic
import Mathlib.RingTheory.Ideal.Basic
#align_import data.polynomial.induction from "leanprover-community/mathlib"@"63417e01fbc711beaf25fa73b6edb395c0cfddd0"
noncomputable section
open Finsupp Finset
namespace Polynomial
open Polynomial
universe u v w x y z
variable {R ... | Mathlib/Algebra/Polynomial/Induction.lean | 75 | 78 | theorem span_le_of_C_coeff_mem (cf : ∀ i : ℕ, C (f.coeff i) ∈ I) :
Ideal.span { g | ∃ i, g = C (f.coeff i) } ≤ I := by |
simp only [@eq_comm _ _ (C _)]
exact (Ideal.span_le.trans range_subset_iff).mpr cf
| [
" M p",
" ∀ {n : ℕ} {a : R}, M (C a * X ^ n)",
" M (C a * X ^ n)",
" M (C a * X ^ 0)",
" M (C a)",
" M (C a * X ^ (n + 1))",
" ∀ (s : Finset ℕ), M (∑ n ∈ s, C (p.coeff n) * X ^ n)",
" M (∑ n ∈ ∅, C (p.coeff n) * X ^ n)",
" ∑ n ∈ ∅, C (p.coeff n) * X ^ n = C 0",
" ∀ ⦃a : ℕ⦄ {s : Finset ℕ}, a ∉ s → ... | [
" M p",
" ∀ {n : ℕ} {a : R}, M (C a * X ^ n)",
" M (C a * X ^ n)",
" M (C a * X ^ 0)",
" M (C a)",
" M (C a * X ^ (n + 1))",
" ∀ (s : Finset ℕ), M (∑ n ∈ s, C (p.coeff n) * X ^ n)",
" M (∑ n ∈ ∅, C (p.coeff n) * X ^ n)",
" ∑ n ∈ ∅, C (p.coeff n) * X ^ n = C 0",
" ∀ ⦃a : ℕ⦄ {s : Finset ℕ}, a ∉ s → ... |
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Data.List.MinMax
import Mathlib.Algebra.Tropical.Basic
import Mathlib.Order.ConditionallyCompleteLattice.Finset
#align_import algebra.tropical.big_operators from "leanprover-community/mathlib"@"d6fad0e5bf2d6f48da9175d25c3dc5706b3834ce"
variable {R S :... | Mathlib/Algebra/Tropical/BigOperators.lean | 58 | 62 | theorem List.untrop_prod [AddMonoid R] (l : List (Tropical R)) :
untrop l.prod = List.sum (l.map untrop) := by |
induction' l with hd tl IH
· simp
· simp [← IH]
| [
" trop l.sum = (map trop l).prod",
" trop [].sum = (map trop []).prod",
" trop (hd :: tl).sum = (map trop (hd :: tl)).prod",
" ∀ (a : List R), trop (sum ⟦a⟧) = (map trop ⟦a⟧).prod",
" trop (∑ i ∈ s, f i) = ∏ i ∈ s, trop (f i)",
" ∏ i ∈ s, trop (f i) = (Multiset.map trop (Multiset.map f s.val)).prod",
" ... | [
" trop l.sum = (map trop l).prod",
" trop [].sum = (map trop []).prod",
" trop (hd :: tl).sum = (map trop (hd :: tl)).prod",
" ∀ (a : List R), trop (sum ⟦a⟧) = (map trop ⟦a⟧).prod",
" trop (∑ i ∈ s, f i) = ∏ i ∈ s, trop (f i)",
" ∏ i ∈ s, trop (f i) = (Multiset.map trop (Multiset.map f s.val)).prod",
" ... |
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 | 53 | 53 | theorem gal_X_sub_C_isSolvable (x : F) : IsSolvable (X - C x).Gal := by | infer_instance
| [
" IsSolvable (Gal 0)",
" IsSolvable (Gal 1)",
" IsSolvable (C x).Gal",
" IsSolvable X.Gal",
" IsSolvable (X - C x).Gal"
] | [
" IsSolvable (Gal 0)",
" IsSolvable (Gal 1)",
" IsSolvable (C x).Gal",
" IsSolvable X.Gal"
] |
import Mathlib.Analysis.Normed.Group.Quotient
import Mathlib.Topology.Instances.AddCircle
#align_import analysis.normed.group.add_circle from "leanprover-community/mathlib"@"084f76e20c88eae536222583331abd9468b08e1c"
noncomputable section
open Set
open Int hiding mem_zmultiples_iff
open AddSubgroup
namespace A... | Mathlib/Analysis/Normed/Group/AddCircle.lean | 71 | 75 | theorem norm_neg_period (x : ℝ) : ‖(x : AddCircle (-p))‖ = ‖(x : AddCircle p)‖ := by |
suffices ‖(↑(-1 * x) : AddCircle (-1 * p))‖ = ‖(x : AddCircle p)‖ by
rw [← this, neg_one_mul]
simp
simp only [norm_coe_mul, abs_neg, abs_one, one_mul]
| [
" ‖↑(t * x)‖ = |t| * ‖↑x‖",
" c * a ∈ zmultiples (c * b)",
" ∃ k, k • (c * b) = c * a",
" ∃ k, k • (c * b) = c * n • b",
" ‖↑(0 * x)‖ = |0| * ‖↑x‖",
" sInf ((fun a => |a|) '' {m | ↑m = ↑(t * x)}) = |t| * sInf ((fun a => |a|) '' {m | ↑m = ↑x})",
"p x t : ℝ\naux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈... | [
" ‖↑(t * x)‖ = |t| * ‖↑x‖",
" c * a ∈ zmultiples (c * b)",
" ∃ k, k • (c * b) = c * a",
" ∃ k, k • (c * b) = c * n • b",
" ‖↑(0 * x)‖ = |0| * ‖↑x‖",
" sInf ((fun a => |a|) '' {m | ↑m = ↑(t * x)}) = |t| * sInf ((fun a => |a|) '' {m | ↑m = ↑x})",
"p x t : ℝ\naux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈... |
import Mathlib.Data.Int.Bitwise
import Mathlib.LinearAlgebra.Matrix.NonsingularInverse
import Mathlib.LinearAlgebra.Matrix.Symmetric
#align_import linear_algebra.matrix.zpow from "leanprover-community/mathlib"@"03fda9112aa6708947da13944a19310684bfdfcb"
open Matrix
namespace Matrix
variable {n' : Type*} [Decidab... | Mathlib/LinearAlgebra/Matrix/ZPow.lean | 50 | 54 | theorem pow_sub' (A : M) {m n : ℕ} (ha : IsUnit A.det) (h : n ≤ m) :
A ^ (m - n) = A ^ m * (A ^ n)⁻¹ := by |
rw [← tsub_add_cancel_of_le h, pow_add, Matrix.mul_assoc, mul_nonsing_inv,
tsub_add_cancel_of_le h, Matrix.mul_one]
simpa using ha.pow n
| [
" Monoid M",
" Inv M",
" A⁻¹ ^ n = (A ^ n)⁻¹",
" A⁻¹ ^ 0 = (A ^ 0)⁻¹",
" A⁻¹ ^ (n + 1) = (A ^ (n + 1))⁻¹",
" A ^ (m - n) = A ^ m * (A ^ n)⁻¹",
" IsUnit (A ^ n).det"
] | [
" Monoid M",
" Inv M",
" A⁻¹ ^ n = (A ^ n)⁻¹",
" A⁻¹ ^ 0 = (A ^ 0)⁻¹",
" A⁻¹ ^ (n + 1) = (A ^ (n + 1))⁻¹"
] |
import Mathlib.Algebra.Group.Basic
import Mathlib.Algebra.Group.Nat
import Mathlib.Init.Data.Nat.Lemmas
#align_import data.nat.psub from "leanprover-community/mathlib"@"70d50ecfd4900dd6d328da39ab7ebd516abe4025"
namespace Nat
def ppred : ℕ → Option ℕ
| 0 => none
| n + 1 => some n
#align nat.ppred Nat.ppred
@... | Mathlib/Data/Nat/PSub.lean | 118 | 122 | theorem psub'_eq_psub (m n) : psub' m n = psub m n := by |
rw [psub']
split_ifs with h
· exact (psub_eq_sub h).symm
· exact (psub_eq_none.2 (not_le.1 h)).symm
| [
" n.pred = n.ppred.getD 0",
" pred 0 = (ppred 0).getD 0",
" (n✝ + 1).pred = (n✝ + 1).ppred.getD 0",
" (m - n).ppred.getD 0 = (m.psub (n + 1)).getD 0",
" ((m.psub n).getD 0).ppred.getD 0 = (m.psub n >>= ppred).getD 0",
" (none.getD 0).ppred.getD 0 = (none >>= ppred).getD 0",
" ((some val✝).getD 0).ppred.... | [
" n.pred = n.ppred.getD 0",
" pred 0 = (ppred 0).getD 0",
" (n✝ + 1).pred = (n✝ + 1).ppred.getD 0",
" (m - n).ppred.getD 0 = (m.psub (n + 1)).getD 0",
" ((m.psub n).getD 0).ppred.getD 0 = (m.psub n >>= ppred).getD 0",
" (none.getD 0).ppred.getD 0 = (none >>= ppred).getD 0",
" ((some val✝).getD 0).ppred.... |
import Mathlib.Data.ZMod.Basic
import Mathlib.GroupTheory.Exponent
#align_import group_theory.specific_groups.dihedral from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
inductive DihedralGroup (n : ℕ) : Type
| r : ZMod n → DihedralGroup n
| sr : ZMod n → DihedralGroup n
derivin... | Mathlib/GroupTheory/SpecificGroups/Dihedral.lean | 170 | 184 | theorem orderOf_r_one : orderOf (r 1 : DihedralGroup n) = n := by |
rcases eq_zero_or_neZero n with (rfl | hn)
· rw [orderOf_eq_zero_iff']
intro n hn
rw [r_one_pow, one_def]
apply mt r.inj
simpa using hn.ne'
· apply (Nat.le_of_dvd (NeZero.pos n) <|
orderOf_dvd_of_pow_eq_one <| @r_one_pow_n n).lt_or_eq.resolve_left
intro h
have h1 : (r 1 : DihedralGr... | [
" ∀ (a b c : DihedralGroup n), a * b * c = a * (b * c)",
" r a * r b * r c = r a * (r b * r c)",
" r a * r b * sr c = r a * (r b * sr c)",
" r a * sr b * r c = r a * (sr b * r c)",
" r a * sr b * sr c = r a * (sr b * sr c)",
" sr a * r b * r c = sr a * (r b * r c)",
" sr a * r b * sr c = sr a * (r b * s... | [
" ∀ (a b c : DihedralGroup n), a * b * c = a * (b * c)",
" r a * r b * r c = r a * (r b * r c)",
" r a * r b * sr c = r a * (r b * sr c)",
" r a * sr b * r c = r a * (sr b * r c)",
" r a * sr b * sr c = r a * (sr b * sr c)",
" sr a * r b * r c = sr a * (r b * r c)",
" sr a * r b * sr c = sr a * (r b * s... |
import Mathlib.Analysis.Normed.Group.Hom
import Mathlib.Analysis.SpecificLimits.Normed
#align_import analysis.normed.group.controlled_closure from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Filter Finset
open Topology
variable {G : Type*} [NormedAddCommGroup G] [CompleteSpace... | Mathlib/Analysis/Normed/Group/ControlledClosure.lean | 116 | 125 | theorem controlled_closure_range_of_complete {f : NormedAddGroupHom G H} {K : Type*}
[SeminormedAddCommGroup K] {j : NormedAddGroupHom K H} (hj : ∀ x, ‖j x‖ = ‖x‖) {C ε : ℝ}
(hC : 0 < C) (hε : 0 < ε) (hyp : ∀ k, ∃ g, f g = j k ∧ ‖g‖ ≤ C * ‖k‖) :
f.SurjectiveOnWith j.range.topologicalClosure (C + ε) := by |
replace hyp : ∀ h ∈ j.range, ∃ g, f g = h ∧ ‖g‖ ≤ C * ‖h‖ := by
intro h h_in
rcases (j.mem_range _).mp h_in with ⟨k, rfl⟩
rw [hj]
exact hyp k
exact controlled_closure_of_complete hC hε hyp
| [
" f.SurjectiveOnWith K.topologicalClosure (C + ε)",
" ∃ g, f g = h ∧ ‖g‖ ≤ (C + ε) * ‖h‖",
" ∃ g, f g = 0 ∧ ‖g‖ ≤ (C + ε) * ‖0‖",
" f 0 = 0 ∧ ‖0‖ ≤ (C + ε) * ‖0‖",
" 0 < b i",
" CauchySeq s",
" 0 < 1 / 2",
" ∀ n ≥ ?m.19377, ‖u n‖ ≤ ?m.19375 * (1 / 2) ^ n",
" ‖u n‖ ≤ ?m.19375 * (1 / 2) ^ n",
" C * ... | [
" f.SurjectiveOnWith K.topologicalClosure (C + ε)",
" ∃ g, f g = h ∧ ‖g‖ ≤ (C + ε) * ‖h‖",
" ∃ g, f g = 0 ∧ ‖g‖ ≤ (C + ε) * ‖0‖",
" f 0 = 0 ∧ ‖0‖ ≤ (C + ε) * ‖0‖",
" 0 < b i",
" CauchySeq s",
" 0 < 1 / 2",
" ∀ n ≥ ?m.19377, ‖u n‖ ≤ ?m.19375 * (1 / 2) ^ n",
" ‖u n‖ ≤ ?m.19375 * (1 / 2) ^ n",
" C * ... |
import Mathlib.CategoryTheory.Adjunction.FullyFaithful
import Mathlib.CategoryTheory.Conj
import Mathlib.CategoryTheory.Functor.ReflectsIso
#align_import category_theory.adjunction.reflective from "leanprover-community/mathlib"@"239d882c4fb58361ee8b3b39fb2091320edef10a"
universe v₁ v₂ v₃ u₁ u₂ u₃
noncomputable s... | Mathlib/CategoryTheory/Adjunction/Reflective.lean | 62 | 67 | theorem unit_obj_eq_map_unit [Reflective i] (X : C) :
(reflectorAdjunction i).unit.app (i.obj ((reflector i).obj X)) =
i.map ((reflector i).map ((reflectorAdjunction i).unit.app X)) := by |
rw [← cancel_mono (i.map ((reflectorAdjunction i).counit.app ((reflector i).obj X))),
← i.map_comp]
simp
| [
" (reflectorAdjunction i).unit.app (i.obj ((reflector i).obj X)) =\n i.map ((reflector i).map ((reflectorAdjunction i).unit.app X))",
" (reflectorAdjunction i).unit.app (i.obj ((reflector i).obj X)) ≫\n i.map ((reflectorAdjunction i).counit.app ((reflector i).obj X)) =\n i.map\n ((reflector i).map... | [] |
import Mathlib.Init.Core
import Mathlib.RingTheory.Polynomial.Cyclotomic.Roots
import Mathlib.NumberTheory.NumberField.Basic
import Mathlib.FieldTheory.Galois
#align_import number_theory.cyclotomic.basic from "leanprover-community/mathlib"@"4b05d3f4f0601dca8abf99c4ec99187682ed0bba"
open Polynomial Algebra FiniteD... | Mathlib/NumberTheory/Cyclotomic/Basic.lean | 154 | 168 | theorem subsingleton_iff [Subsingleton B] : IsCyclotomicExtension S A B ↔ S = { } ∨ S = {1} := by |
have : Subsingleton (Subalgebra A B) := inferInstance
constructor
· rintro ⟨hprim, -⟩
rw [← subset_singleton_iff_eq]
intro t ht
obtain ⟨ζ, hζ⟩ := hprim ht
rw [mem_singleton_iff, ← PNat.coe_eq_one_iff]
exact mod_cast hζ.unique (IsPrimitiveRoot.of_subsingleton ζ)
· rintro (rfl | rfl)
-- Porti... | [
" IsCyclotomicExtension {n} A B ↔ (∃ r, IsPrimitiveRoot r ↑n) ∧ ∀ (x : B), x ∈ adjoin A {b | b ^ ↑n = 1}",
" ⊥ = ⊤",
" x ∈ ⊥",
" IsCyclotomicExtension ∅ A B",
" ∃ r, IsPrimitiveRoot r ↑s",
" x ∈ adjoin A {b | ∃ n ∈ ∅, b ^ ↑n = 1}",
" IsCyclotomicExtension (S ∪ T) A C",
" ∃ r, IsPrimitiveRoot r ↑n✝",
... | [
" IsCyclotomicExtension {n} A B ↔ (∃ r, IsPrimitiveRoot r ↑n) ∧ ∀ (x : B), x ∈ adjoin A {b | b ^ ↑n = 1}",
" ⊥ = ⊤",
" x ∈ ⊥",
" IsCyclotomicExtension ∅ A B",
" ∃ r, IsPrimitiveRoot r ↑s",
" x ∈ adjoin A {b | ∃ n ∈ ∅, b ^ ↑n = 1}",
" IsCyclotomicExtension (S ∪ T) A C",
" ∃ r, IsPrimitiveRoot r ↑n✝",
... |
import Mathlib.Data.List.Chain
#align_import data.list.destutter from "leanprover-community/mathlib"@"7b78d1776212a91ecc94cf601f83bdcc46b04213"
variable {α : Type*} (l : List α) (R : α → α → Prop) [DecidableRel R] {a b : α}
namespace List
@[simp]
theorem destutter'_nil : destutter' R a [] = [a] :=
rfl
#align ... | Mathlib/Data/List/Destutter.lean | 92 | 98 | theorem destutter'_is_chain' (a) : (l.destutter' R a).Chain' R := by |
induction' l with b l hl generalizing a
· simp
rw [destutter']
split_ifs with h
· exact destutter'_is_chain R l h
· exact hl a
| [
" destutter' R b (a :: l) = b :: destutter' R a l",
" destutter' R b (a :: l) = destutter' R b l",
" destutter' R a [b] = if R a b then [a, b] else [a]",
" destutter' R a [b] = [a, b]",
" destutter' R a [b] = [a]",
" destutter' R a l <+ a :: l",
" destutter' R a [] <+ [a]",
" destutter' R a (b :: l) <... | [
" destutter' R b (a :: l) = b :: destutter' R a l",
" destutter' R b (a :: l) = destutter' R b l",
" destutter' R a [b] = if R a b then [a, b] else [a]",
" destutter' R a [b] = [a, b]",
" destutter' R a [b] = [a]",
" destutter' R a l <+ a :: l",
" destutter' R a [] <+ [a]",
" destutter' R a (b :: l) <... |
import Mathlib.Algebra.ContinuedFractions.Computation.Approximations
import Mathlib.Algebra.ContinuedFractions.Computation.CorrectnessTerminating
import Mathlib.Data.Rat.Floor
#align_import algebra.continued_fractions.computation.terminates_iff_rat from "leanprover-community/mathlib"@"a7e36e48519ab281320c4d192da6a7b3... | Mathlib/Algebra/ContinuedFractions/Computation/TerminatesIffRat.lean | 315 | 331 | theorem exists_nth_stream_eq_none_of_rat (q : ℚ) : ∃ n : ℕ, IntFractPair.stream q n = none := by |
let fract_q_num := (Int.fract q).num; let n := fract_q_num.natAbs + 1
cases' stream_nth_eq : IntFractPair.stream q n with ifp
· use n, stream_nth_eq
· -- arrive at a contradiction since the numerator decreased num + 1 times but every fractional
-- value is nonnegative.
have ifp_fr_num_le_q_fr_num_sub_n... | [
" ifp_succ_n.fr.num < ifp_n.fr.num",
" ifp_n = ifp_n'",
" (IntFractPair.of ifp_n.fr⁻¹).fr.num < ifp_n.fr.num",
" ∀ {ifp_n : IntFractPair ℚ}, IntFractPair.stream q n = some ifp_n → ifp_n.fr.num ≤ (IntFractPair.of q).fr.num - ↑n",
" ∀ {ifp_n : IntFractPair ℚ}, IntFractPair.stream q 0 = some ifp_n → ifp_n.fr.n... | [
" ifp_succ_n.fr.num < ifp_n.fr.num",
" ifp_n = ifp_n'",
" (IntFractPair.of ifp_n.fr⁻¹).fr.num < ifp_n.fr.num",
" ∀ {ifp_n : IntFractPair ℚ}, IntFractPair.stream q n = some ifp_n → ifp_n.fr.num ≤ (IntFractPair.of q).fr.num - ↑n",
" ∀ {ifp_n : IntFractPair ℚ}, IntFractPair.stream q 0 = some ifp_n → ifp_n.fr.n... |
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 | 96 | 96 | theorem truncation_zero (f : α → ℝ) : truncation f 0 = 0 := by | simp [truncation]; rfl
| [
" 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"
] | [
" 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|"
] |
import Mathlib.Analysis.SpecialFunctions.Gamma.Basic
import Mathlib.Analysis.SpecialFunctions.PolarCoord
import Mathlib.Analysis.Convex.Complex
#align_import analysis.special_functions.gaussian from "leanprover-community/mathlib"@"7982767093ae38cba236487f9c9dd9cd99f63c16"
noncomputable section
open Real Set Measu... | Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean | 45 | 48 | theorem exp_neg_mul_sq_isLittleO_exp_neg {b : ℝ} (hb : 0 < b) :
(fun x : ℝ => exp (-b * x ^ 2)) =o[atTop] fun x : ℝ => exp (-x) := by |
simp_rw [← rpow_two]
exact exp_neg_mul_rpow_isLittleO_exp_neg hb one_lt_two
| [
" (fun x => rexp (-b * x ^ p)) =o[atTop] fun x => rexp (-x)",
" Tendsto (fun x => -x - -b * x ^ p) atTop atTop",
" (fun x => x * (b * x ^ (p - 1) + -1)) =ᶠ[atTop] fun x => -x - -b * x ^ p",
" x * (b * x ^ (p - 1) + -1) = -x - -b * x ^ p",
" x * (b * (x ^ p / x) + -1) = -x - -b * x ^ p",
" b * x ^ p + -x =... | [
" (fun x => rexp (-b * x ^ p)) =o[atTop] fun x => rexp (-x)",
" Tendsto (fun x => -x - -b * x ^ p) atTop atTop",
" (fun x => x * (b * x ^ (p - 1) + -1)) =ᶠ[atTop] fun x => -x - -b * x ^ p",
" x * (b * x ^ (p - 1) + -1) = -x - -b * x ^ p",
" x * (b * (x ^ p / x) + -1) = -x - -b * x ^ p",
" b * x ^ p + -x =... |
import Mathlib.Algebra.Polynomial.Mirror
import Mathlib.Analysis.Complex.Polynomial
#align_import data.polynomial.unit_trinomial from "leanprover-community/mathlib"@"302eab4f46abb63de520828de78c04cb0f9b5836"
namespace Polynomial
open scoped Polynomial
open Finset
section Semiring
variable {R : Type*} [Semirin... | Mathlib/Algebra/Polynomial/UnitTrinomial.lean | 110 | 117 | theorem trinomial_mirror (hkm : k < m) (hmn : m < n) (hu : u ≠ 0) (hw : w ≠ 0) :
(trinomial k m n u v w).mirror = trinomial k (n - m + k) n w v u := by |
rw [mirror, trinomial_natTrailingDegree hkm hmn hu, reverse, trinomial_natDegree hkm hmn hw,
trinomial_def, reflect_add, reflect_add, reflect_C_mul_X_pow, reflect_C_mul_X_pow,
reflect_C_mul_X_pow, revAt_le (hkm.trans hmn).le, revAt_le hmn.le, revAt_le le_rfl, add_mul,
add_mul, mul_assoc, mul_assoc, mul_a... | [
" (trinomial k m n u v w).coeff n = w",
" (trinomial k m n u v w).coeff m = v",
" (trinomial k m n u v w).coeff k = u",
" (trinomial k m n u v w).natDegree = n",
" (trinomial k m n u v w).coeff n ≠ 0",
" ↑i ≤ ↑n",
" ↑i ≤ ↑i",
" (trinomial k m n u v w).natTrailingDegree = k",
" (trinomial k m n u v w... | [
" (trinomial k m n u v w).coeff n = w",
" (trinomial k m n u v w).coeff m = v",
" (trinomial k m n u v w).coeff k = u",
" (trinomial k m n u v w).natDegree = n",
" (trinomial k m n u v w).coeff n ≠ 0",
" ↑i ≤ ↑n",
" ↑i ≤ ↑i",
" (trinomial k m n u v w).natTrailingDegree = k",
" (trinomial k m n u v w... |
import Mathlib.Data.Nat.Choose.Central
import Mathlib.Data.Nat.Factorization.Basic
import Mathlib.Data.Nat.Multiplicity
#align_import data.nat.choose.factorization from "leanprover-community/mathlib"@"dc9db541168768af03fe228703e758e649afdbfc"
namespace Nat
variable {p n k : ℕ}
theorem factorization_choose_le_l... | Mathlib/Data/Nat/Choose/Factorization.lean | 106 | 110 | theorem factorization_choose_eq_zero_of_lt (h : n < p) : (choose n k).factorization p = 0 := by |
by_cases hnk : n < k; · simp [choose_eq_zero_of_lt hnk]
rw [choose_eq_factorial_div_factorial (le_of_not_lt hnk),
factorization_div (factorial_mul_factorial_dvd_factorial (le_of_not_lt hnk)), Finsupp.coe_tsub,
Pi.sub_apply, factorization_factorial_eq_zero_of_lt h, zero_tsub]
| [
" (n.choose k).factorization p ≤ p.log n",
" k ≤ n",
" (n.choose k).factorization p = 0",
" (multiplicity p (n.choose k)).get ⋯ ≤ p.log n",
" (Finset.filter (fun i => p ^ i ≤ k % p ^ i + (n - k) % p ^ i) (Finset.Ico 1 (p.log n + 1))).card ≤ p.log n",
" (n.choose k).factorization p ≤ 1",
" p.log n ≤ 1",
... | [
" (n.choose k).factorization p ≤ p.log n",
" k ≤ n",
" (n.choose k).factorization p = 0",
" (multiplicity p (n.choose k)).get ⋯ ≤ p.log n",
" (Finset.filter (fun i => p ^ i ≤ k % p ^ i + (n - k) % p ^ i) (Finset.Ico 1 (p.log n + 1))).card ≤ p.log n",
" (n.choose k).factorization p ≤ 1",
" p.log n ≤ 1",
... |
import Mathlib.Algebra.CharP.Invertible
import Mathlib.Analysis.NormedSpace.Basic
import Mathlib.Analysis.Normed.Group.AddTorsor
import Mathlib.LinearAlgebra.AffineSpace.AffineSubspace
import Mathlib.Topology.Instances.RealVectorSpace
#align_import analysis.normed_space.add_torsor from "leanprover-community/mathlib"@... | Mathlib/Analysis/NormedSpace/AddTorsor.lean | 109 | 111 | theorem dist_lineMap_right (p₁ p₂ : P) (c : 𝕜) :
dist (lineMap p₁ p₂ c) p₂ = ‖1 - c‖ * dist p₁ p₂ := by |
simpa only [lineMap_apply_one, dist_eq_norm'] using dist_lineMap_lineMap p₁ p₂ c 1
| [
" IsClosed ↑s.direction ↔ IsClosed ↑s",
" IsClosed ↑⊥.direction ↔ IsClosed ↑⊥",
" IsClosed ((fun x_1 => x_1 -ᵥ x) '' ↑s) ↔ IsClosed (⇑(IsometryEquiv.vaddConst x).toHomeomorph.symm '' ↑s)",
" dist p₁ ((homothety p₁ c) p₂) = ‖c‖ * dist p₁ p₂",
" dist ((homothety p₁ c) p₂) p₁ = ‖c‖ * dist p₁ p₂",
" dist ((li... | [
" IsClosed ↑s.direction ↔ IsClosed ↑s",
" IsClosed ↑⊥.direction ↔ IsClosed ↑⊥",
" IsClosed ((fun x_1 => x_1 -ᵥ x) '' ↑s) ↔ IsClosed (⇑(IsometryEquiv.vaddConst x).toHomeomorph.symm '' ↑s)",
" dist p₁ ((homothety p₁ c) p₂) = ‖c‖ * dist p₁ p₂",
" dist ((homothety p₁ c) p₂) p₁ = ‖c‖ * dist p₁ p₂",
" dist ((li... |
import Mathlib.Data.Matrix.Basic
import Mathlib.Data.Matrix.RowCol
import Mathlib.Data.Fin.VecNotation
import Mathlib.Tactic.FinCases
#align_import data.matrix.notation from "leanprover-community/mathlib"@"a99f85220eaf38f14f94e04699943e185a5e1d1a"
namespace Matrix
universe u uₘ uₙ uₒ
variable {α : Type u} {o n m... | Mathlib/Data/Matrix/Notation.lean | 230 | 232 | theorem tail_transpose (A : Matrix m' (Fin n.succ) α) : vecTail (of.symm Aᵀ) = (vecTail ∘ A)ᵀ := by |
ext i j
rfl
| [
" vecCons v B i j = vecCons (v j) (fun i => B i j) i",
" vecCons v B 0 j = vecCons (v j) (fun i => B i j) 0",
" ∀ (i : Fin m), vecCons v B i.succ j = vecCons (v j) (fun i => B i j) i.succ",
" (of (vecCons v A))ᵀ = of fun i => vecCons (v i) (Aᵀ i)",
" (of (vecCons v A))ᵀ i j = of (fun i => vecCons (v i) (Aᵀ ... | [
" vecCons v B i j = vecCons (v j) (fun i => B i j) i",
" vecCons v B 0 j = vecCons (v j) (fun i => B i j) 0",
" ∀ (i : Fin m), vecCons v B i.succ j = vecCons (v j) (fun i => B i j) i.succ",
" (of (vecCons v A))ᵀ = of fun i => vecCons (v i) (Aᵀ i)",
" (of (vecCons v A))ᵀ i j = of (fun i => vecCons (v i) (Aᵀ ... |
import Mathlib.AlgebraicGeometry.AffineScheme
import Mathlib.RingTheory.Nilpotent.Lemmas
import Mathlib.Topology.Sheaves.SheafCondition.Sites
import Mathlib.Algebra.Category.Ring.Constructions
import Mathlib.RingTheory.LocalProperties
#align_import algebraic_geometry.properties from "leanprover-community/mathlib"@"88... | Mathlib/AlgebraicGeometry/Properties.lean | 61 | 68 | theorem isReducedOfStalkIsReduced [∀ x : X.carrier, _root_.IsReduced (X.presheaf.stalk x)] :
IsReduced X := by |
refine ⟨fun U => ⟨fun s hs => ?_⟩⟩
apply Presheaf.section_ext X.sheaf U s 0
intro x
rw [RingHom.map_zero]
change X.presheaf.germ x s = 0
exact (hs.map _).eq_zero
| [
" T0Space ↑↑X.toPresheafedSpace",
" ∃ s, x ∈ s ∧ IsOpen s ∧ T0Space ↑s",
" QuasiSober ↑↑X.toPresheafedSpace",
" ∀ (s : ↑(Set.range fun x => Set.range ⇑(X.affineCover.map x).val.base)), IsOpen ↑s",
" IsOpen ↑⟨(fun x => Set.range ⇑(X.affineCover.map x).val.base) i, ⋯⟩",
" ∀ (s : ↑(Set.range fun x => Set.ran... | [
" T0Space ↑↑X.toPresheafedSpace",
" ∃ s, x ∈ s ∧ IsOpen s ∧ T0Space ↑s",
" QuasiSober ↑↑X.toPresheafedSpace",
" ∀ (s : ↑(Set.range fun x => Set.range ⇑(X.affineCover.map x).val.base)), IsOpen ↑s",
" IsOpen ↑⟨(fun x => Set.range ⇑(X.affineCover.map x).val.base) i, ⋯⟩",
" ∀ (s : ↑(Set.range fun x => Set.ran... |
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 | 88 | 92 | theorem sum_smul_eq_zero_of_isTrivialRelation (h : IsTrivialRelation f x) :
∑ i, f i • x i = 0 := by |
simpa using
congr_arg (TensorProduct.lid R M) <|
sum_tmul_eq_zero_of_vanishesTrivially R (isTrivialRelation_iff_vanishesTrivially.mp h)
| [
" IsTrivialRelation f x ↔ VanishesTrivially R f x",
" ∑ i : ι, f i • x i = 0"
] | [
" IsTrivialRelation f x ↔ VanishesTrivially R f x"
] |
import Mathlib.GroupTheory.Sylow
import Mathlib.GroupTheory.Transfer
#align_import group_theory.schur_zassenhaus from "leanprover-community/mathlib"@"d57133e49cf06508700ef69030cd099917e0f0de"
namespace Subgroup
section SchurZassenhausAbelian
open MulOpposite MulAction Subgroup.leftTransversals MemLeftTransversa... | Mathlib/GroupTheory/SchurZassenhaus.lean | 92 | 99 | theorem eq_one_of_smul_eq_one (hH : Nat.Coprime (Nat.card H) H.index) (α : H.QuotientDiff)
(h : H) : h • α = α → h = 1 :=
Quotient.inductionOn' α fun α hα =>
(powCoprime hH).injective <|
calc
h ^ H.index = diff (MonoidHom.id H) (op ((h⁻¹ : H) : G) • α) α := by |
rw [← diff_inv, smul_diff', diff_self, one_mul, inv_pow, inv_inv]
_ = 1 ^ H.index := (Quotient.exact' hα).trans (one_pow H.index).symm
| [
" diff (MonoidHom.id ↥H) y✝ x✝ = 1",
" diff (MonoidHom.id ↥H) x✝ z✝ = 1",
" Inhabited H.QuotientDiff",
" Inhabited (Quotient { r := fun α β => diff (MonoidHom.id ↥H) α β = 1, iseqv := ⋯ })",
" diff (MonoidHom.id ↥H) (g • α) (g • β) = ⟨g.unop⁻¹ * ↑(diff (MonoidHom.id ↥H) α β) * g.unop, ⋯⟩",
" (fun h => ⟨g.... | [
" diff (MonoidHom.id ↥H) y✝ x✝ = 1",
" diff (MonoidHom.id ↥H) x✝ z✝ = 1",
" Inhabited H.QuotientDiff",
" Inhabited (Quotient { r := fun α β => diff (MonoidHom.id ↥H) α β = 1, iseqv := ⋯ })",
" diff (MonoidHom.id ↥H) (g • α) (g • β) = ⟨g.unop⁻¹ * ↑(diff (MonoidHom.id ↥H) α β) * g.unop, ⋯⟩",
" (fun h => ⟨g.... |
import Mathlib.CategoryTheory.Limits.Preserves.Shapes.BinaryProducts
import Mathlib.CategoryTheory.Limits.Preserves.Shapes.Products
import Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts
import Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts
import Mathlib.Logic.Equiv.Fin
#align_import category_theory.limits.... | Mathlib/CategoryTheory/Limits/Constructions/FiniteProductsOfBinaryProducts.lean | 106 | 110 | theorem hasFiniteProducts_of_has_binary_and_terminal : HasFiniteProducts C := by |
refine ⟨fun n => ⟨fun K => ?_⟩⟩
letI := hasProduct_fin n fun n => K.obj ⟨n⟩
let that : (Discrete.functor fun n => K.obj ⟨n⟩) ≅ K := Discrete.natIso fun ⟨i⟩ => Iso.refl _
apply @hasLimitOfIso _ _ _ _ _ _ this that
| [
" (b : Fin (n + 1)) → c₂.pt ⟶ f b",
" c₂.pt ⟶ f 0",
" (i : Fin n) → c₂.pt ⟶ f i.succ",
" c₂.pt ⟶ f i.succ",
" s.pt ⟶ (extendFan c₁ c₂).pt",
" ((Functor.const (Discrete (Fin (n + 1)))).obj s.pt).obj { as := 0 } ⟶ c₁.pt",
" (fun s =>\n ↑(BinaryFan.IsLimit.lift' t₂ (s.π.app { as := 0 })\n ... | [
" (b : Fin (n + 1)) → c₂.pt ⟶ f b",
" c₂.pt ⟶ f 0",
" (i : Fin n) → c₂.pt ⟶ f i.succ",
" c₂.pt ⟶ f i.succ",
" s.pt ⟶ (extendFan c₁ c₂).pt",
" ((Functor.const (Discrete (Fin (n + 1)))).obj s.pt).obj { as := 0 } ⟶ c₁.pt",
" (fun s =>\n ↑(BinaryFan.IsLimit.lift' t₂ (s.π.app { as := 0 })\n ... |
import Mathlib.RingTheory.TensorProduct.Basic
import Mathlib.Algebra.Module.ULift
#align_import ring_theory.is_tensor_product from "leanprover-community/mathlib"@"c4926d76bb9c5a4a62ed2f03d998081786132105"
universe u v₁ v₂ v₃ v₄
open TensorProduct
section IsTensorProduct
variable {R : Type*} [CommSemiring R]
va... | Mathlib/RingTheory/IsTensorProduct.lean | 115 | 127 | theorem IsTensorProduct.inductionOn (h : IsTensorProduct f) {C : M → Prop} (m : M) (h0 : C 0)
(htmul : ∀ x y, C (f x y)) (hadd : ∀ x y, C x → C y → C (x + y)) : C m := by |
rw [← h.equiv.right_inv m]
generalize h.equiv.invFun m = y
change C (TensorProduct.lift f y)
induction y using TensorProduct.induction_on with
| zero => rwa [map_zero]
| tmul _ _ =>
rw [TensorProduct.lift.tmul]
apply htmul
| add _ _ _ _ =>
rw [map_add]
apply hadd <;> assumption
| [
" IsTensorProduct (mk R M N)",
" Function.Bijective ⇑(lift (mk R M N))",
" lift (mk R M N) = LinearMap.id",
" ∀ (x : M) (y : N), (lift (mk R M N)) (x ⊗ₜ[R] y) = LinearMap.id (x ⊗ₜ[R] y)",
" Function.Bijective ⇑LinearMap.id",
" h.equiv.symm ((f x₁) x₂) = x₁ ⊗ₜ[R] x₂",
" h.equiv (h.equiv.symm ((f x₁) x₂))... | [
" IsTensorProduct (mk R M N)",
" Function.Bijective ⇑(lift (mk R M N))",
" lift (mk R M N) = LinearMap.id",
" ∀ (x : M) (y : N), (lift (mk R M N)) (x ⊗ₜ[R] y) = LinearMap.id (x ⊗ₜ[R] y)",
" Function.Bijective ⇑LinearMap.id",
" h.equiv.symm ((f x₁) x₂) = x₁ ⊗ₜ[R] x₂",
" h.equiv (h.equiv.symm ((f x₁) x₂))... |
import Mathlib.Data.Finset.Prod
import Mathlib.Data.Set.Finite
#align_import data.finset.n_ary from "leanprover-community/mathlib"@"eba7871095e834365616b5e43c8c7bb0b37058d0"
open Function Set
variable {α α' β β' γ γ' δ δ' ε ε' ζ ζ' ν : Type*}
namespace Finset
variable [DecidableEq α'] [DecidableEq β'] [Decidabl... | Mathlib/Data/Finset/NAry.lean | 43 | 44 | theorem mem_image₂ : c ∈ image₂ f s t ↔ ∃ a ∈ s, ∃ b ∈ t, f a b = c := by |
simp [image₂, and_assoc]
| [
" c ∈ image₂ f s t ↔ ∃ a ∈ s, ∃ b ∈ t, f a b = c"
] | [] |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.GroupTheory.GroupAction.Pi
open Function Set
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
protected... | Mathlib/Algebra/AddConstMap/Basic.lean | 151 | 152 | theorem map_nat_add [AddCommMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (n : ℕ) (x : G) : f (↑n + x) = f x + n := by | simp
| [
" f (x + n • a) = f x + n • b",
" f (x + ↑n) = f x + n • b",
" f (x + ↑n) = f x + ↑n",
" f a = f 0 + b",
" f (n • a) = f 0 + n • b",
" f ↑n = f 0 + n • b",
" f ↑n = f 0 + ↑n",
" f (a + x) = f x + b",
" f (n • a + x) = f x + n • b",
" f (↑n + x) = f x + n • b",
" f (↑n + x) = f x + ↑n"
] | [
" f (x + n • a) = f x + n • b",
" f (x + ↑n) = f x + n • b",
" f (x + ↑n) = f x + ↑n",
" f a = f 0 + b",
" f (n • a) = f 0 + n • b",
" f ↑n = f 0 + n • b",
" f ↑n = f 0 + ↑n",
" f (a + x) = f x + b",
" f (n • a + x) = f x + n • b",
" f (↑n + x) = f x + n • b"
] |
import Mathlib.CategoryTheory.Limits.Constructions.Pullbacks
import Mathlib.CategoryTheory.Preadditive.Biproducts
import Mathlib.CategoryTheory.Limits.Preserves.Shapes.Kernels
import Mathlib.CategoryTheory.Limits.Shapes.Images
import Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers
import Math... | Mathlib/CategoryTheory/Abelian/Basic.lean | 147 | 152 | theorem imageMonoFactorisation_e' {X Y : C} (f : X ⟶ Y) :
(imageMonoFactorisation f).e = cokernel.π _ ≫ Abelian.coimageImageComparison f := by |
dsimp
ext
simp only [Abelian.coimageImageComparison, imageMonoFactorisation_e, Category.assoc,
cokernel.π_desc_assoc]
| [
" (imageMonoFactorisation f).e = cokernel.π (kernel.ι f) ≫ coimageImageComparison f",
" kernel.lift (cokernel.π f) f ⋯ = cokernel.π (kernel.ι f) ≫ coimageImageComparison f",
" kernel.lift (cokernel.π f) f ⋯ ≫ equalizer.ι (cokernel.π f) 0 =\n (cokernel.π (kernel.ι f) ≫ coimageImageComparison f) ≫ equalizer.ι ... | [] |
import Mathlib.Analysis.Calculus.Deriv.Pow
import Mathlib.Analysis.SpecialFunctions.Log.Basic
import Mathlib.Analysis.SpecialFunctions.ExpDeriv
import Mathlib.Tactic.AdaptationNote
#align_import analysis.special_functions.log.deriv from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
ope... | Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean | 42 | 47 | theorem hasStrictDerivAt_log (hx : x ≠ 0) : HasStrictDerivAt log x⁻¹ x := by |
cases' hx.lt_or_lt with hx hx
· convert (hasStrictDerivAt_log_of_pos (neg_pos.mpr hx)).comp x (hasStrictDerivAt_neg x) using 1
· ext y; exact (log_neg_eq_log y).symm
· field_simp [hx.ne]
· exact hasStrictDerivAt_log_of_pos hx
| [
" HasStrictDerivAt log x⁻¹ x",
" log = log ∘ Neg.neg",
" y.log = (log ∘ Neg.neg) y",
" x⁻¹ = (-x)⁻¹ * -1"
] | [
" HasStrictDerivAt log x⁻¹ x"
] |
import Mathlib.Data.List.Chain
import Mathlib.Data.List.Enum
import Mathlib.Data.List.Nodup
import Mathlib.Data.List.Pairwise
import Mathlib.Data.List.Zip
#align_import data.list.range from "leanprover-community/mathlib"@"7b78d1776212a91ecc94cf601f83bdcc46b04213"
set_option autoImplicit true
universe u
open Nat... | Mathlib/Data/List/Range.lean | 79 | 80 | theorem pairwise_lt_range (n : ℕ) : Pairwise (· < ·) (range n) := by |
simp (config := {decide := true}) only [range_eq_range', pairwise_lt_range']
| [
" (range' n m).nthLe i H = n + i",
" Pairwise (fun x x_1 => x < x_1) (range n)"
] | [
" (range' n m).nthLe i H = n + i"
] |
import Mathlib.Data.Multiset.Powerset
#align_import data.multiset.antidiagonal from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
assert_not_exists Ring
universe u
namespace Multiset
open List
variable {α β : Type*}
def antidiagonal (s : Multiset α) : Multiset (Multiset α × Multis... | Mathlib/Data/Multiset/Antidiagonal.lean | 103 | 105 | theorem card_antidiagonal (s : Multiset α) : card (antidiagonal s) = 2 ^ card s := by |
have := card_powerset s
rwa [← antidiagonal_map_fst, card_map] at this
| [
" x ∈ antidiagonal ⟦l⟧ ↔ x.1 + x.2 = ⟦l⟧",
" x ∈ ↑(powersetAux l).revzip ↔ x.1 + x.2 = ↑l",
" x ∈ ↑(powersetAux l).revzip",
" ∃ a ≤ x.1 + x.2, (a, x.1 + x.2 - a) = x",
" ∃ a ≤ (x₁, x₂).1 + (x₁, x₂).2, (a, (x₁, x₂).1 + (x₁, x₂).2 - a) = (x₁, x₂)",
" (x₁, (x₁, x₂).1 + (x₁, x₂).2 - x₁) = (x₁, x₂)",
" map P... | [
" x ∈ antidiagonal ⟦l⟧ ↔ x.1 + x.2 = ⟦l⟧",
" x ∈ ↑(powersetAux l).revzip ↔ x.1 + x.2 = ↑l",
" x ∈ ↑(powersetAux l).revzip",
" ∃ a ≤ x.1 + x.2, (a, x.1 + x.2 - a) = x",
" ∃ a ≤ (x₁, x₂).1 + (x₁, x₂).2, (a, (x₁, x₂).1 + (x₁, x₂).2 - a) = (x₁, x₂)",
" (x₁, (x₁, x₂).1 + (x₁, x₂).2 - x₁) = (x₁, x₂)",
" map P... |
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Combinatorics.Hall.Basic
import Mathlib.Data.Fintype.BigOperators
import Mathlib.SetTheory.Cardinal.Finite
#align_import combinatorics.configuration from "leanprover-community/mathlib"@"d2d8742b0c21426362a9dacebc6005db895ca963"
open Finset
nam... | Mathlib/Combinatorics/Configuration.lean | 125 | 166 | theorem Nondegenerate.exists_injective_of_card_le [Nondegenerate P L] [Fintype P] [Fintype L]
(h : Fintype.card L ≤ Fintype.card P) : ∃ f : L → P, Function.Injective f ∧ ∀ l, f l ∉ l := by |
classical
let t : L → Finset P := fun l => Set.toFinset { p | p ∉ l }
suffices ∀ s : Finset L, s.card ≤ (s.biUnion t).card by
-- Hall's marriage theorem
obtain ⟨f, hf1, hf2⟩ := (Finset.all_card_le_biUnion_card_iff_exists_injective t).mp this
exact ⟨f, hf1, fun l => Set.mem_toFinset.mp (hf2 ... | [
" ∃ f, Function.Injective f ∧ ∀ (l : L), f l ∉ l",
" ∀ (s : Finset L), s.card ≤ (s.biUnion t).card",
" s.card ≤ (s.biUnion t).card",
" {l}.card ≤ ({l}.biUnion t).card",
" (t l).card ≠ 0",
" (s.biUnion t)ᶜ.card ≤ sᶜ.card",
" (s.biUnion t)ᶜ.card ≤ 1",
" p₁ = p₂",
" (s.biUnion t)ᶜ.card = 0",
" s.biUn... | [] |
import Mathlib.Combinatorics.SimpleGraph.Finite
import Mathlib.Data.Finset.Sym
import Mathlib.Data.Matrix.Basic
#align_import combinatorics.simple_graph.inc_matrix from "leanprover-community/mathlib"@"bb168510ef455e9280a152e7f31673cabd3d7496"
open Finset Matrix SimpleGraph Sym2
open Matrix
namespace SimpleGraph... | Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean | 69 | 72 | theorem incMatrix_apply' [Zero R] [One R] [DecidableEq α] [DecidableRel G.Adj] {a : α}
{e : Sym2 α} : G.incMatrix R a e = if e ∈ G.incidenceSet a then 1 else 0 := by |
unfold incMatrix Set.indicator
convert rfl
| [
" incMatrix R G a e = if e ∈ G.incidenceSet a then 1 else 0",
" (if e ∈ G.incidenceSet a then 1 e else 0) = if e ∈ G.incidenceSet a then 1 else 0"
] | [] |
import Mathlib.MeasureTheory.Integral.SetIntegral
#align_import measure_theory.integral.average from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open ENNReal MeasureTheory MeasureTheory.Measure Metric Set Filter TopologicalSpace Function
open scoped Topology ENNReal Convex
variable... | Mathlib/MeasureTheory/Integral/Average.lean | 149 | 150 | theorem setLaverage_congr (h : s =ᵐ[μ] t) : ⨍⁻ x in s, f x ∂μ = ⨍⁻ x in t, f x ∂μ := by |
simp only [setLaverage_eq, set_lintegral_congr h, measure_congr h]
| [
" ⨍⁻ (_x : α), 0 ∂μ = 0",
" ⨍⁻ (x : α), f x ∂0 = 0",
" ⨍⁻ (x : α), f x ∂μ = (∫⁻ (x : α), f x ∂μ) / μ univ",
" ⨍⁻ (x : α), f x ∂μ = ∫⁻ (x : α), f x ∂μ",
" μ univ * ⨍⁻ (x : α), f x ∂μ = ∫⁻ (x : α), f x ∂μ",
" ⨍⁻ (x : α) in s, f x ∂μ = (∫⁻ (x : α) in s, f x ∂μ) / μ s",
" ⨍⁻ (x : α) in s, f x ∂μ = ∫⁻ (x : α... | [
" ⨍⁻ (_x : α), 0 ∂μ = 0",
" ⨍⁻ (x : α), f x ∂0 = 0",
" ⨍⁻ (x : α), f x ∂μ = (∫⁻ (x : α), f x ∂μ) / μ univ",
" ⨍⁻ (x : α), f x ∂μ = ∫⁻ (x : α), f x ∂μ",
" μ univ * ⨍⁻ (x : α), f x ∂μ = ∫⁻ (x : α), f x ∂μ",
" ⨍⁻ (x : α) in s, f x ∂μ = (∫⁻ (x : α) in s, f x ∂μ) / μ s",
" ⨍⁻ (x : α) in s, f x ∂μ = ∫⁻ (x : α... |
import Mathlib.Probability.Notation
import Mathlib.Probability.Process.Stopping
#align_import probability.martingale.basic from "leanprover-community/mathlib"@"ba074af83b6cf54c3104e59402b39410ddbd6dca"
open TopologicalSpace Filter
open scoped NNReal ENNReal MeasureTheory ProbabilityTheory
namespace MeasureTheor... | Mathlib/Probability/Martingale/Basic.lean | 75 | 79 | theorem martingale_const_fun [OrderBot ι] (ℱ : Filtration ι m0) (μ : Measure Ω) [IsFiniteMeasure μ]
{f : Ω → E} (hf : StronglyMeasurable[ℱ ⊥] f) (hfint : Integrable f μ) :
Martingale (fun _ => f) ℱ μ := by |
refine ⟨fun i => hf.mono <| ℱ.mono bot_le, fun i j _ => ?_⟩
rw [condexp_of_stronglyMeasurable (ℱ.le _) (hf.mono <| ℱ.mono bot_le) hfint]
| [
" μ[(fun x_1 x_2 => x) j|↑ℱ i] =ᶠ[ae μ] (fun x_1 x_2 => x) i",
" Martingale (fun x => f) ℱ μ",
" μ[(fun x => f) j|↑ℱ i] =ᶠ[ae μ] (fun x => f) i"
] | [
" μ[(fun x_1 x_2 => x) j|↑ℱ i] =ᶠ[ae μ] (fun x_1 x_2 => x) i"
] |
import Mathlib.Analysis.Convex.Side
import Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation
import Mathlib.Geometry.Euclidean.Angle.Unoriented.Affine
#align_import geometry.euclidean.angle.oriented.affine from "leanprover-community/mathlib"@"46b633fd842bef9469441c0209906f6dddd2b4f5"
noncomputable section
open ... | Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean | 80 | 81 | theorem right_ne_of_oangle_ne_zero {p₁ p₂ p₃ : P} (h : ∡ p₁ p₂ p₃ ≠ 0) : p₃ ≠ p₂ := by |
rw [← @vsub_ne_zero V]; exact o.right_ne_zero_of_oangle_ne_zero h
| [
" ContinuousAt (fun y => ∡ y.1 y.2.1 y.2.2) x",
" (f x).1 ≠ 0",
" (f x).2 ≠ 0",
" ∡ p₁ p₁ p₂ = 0",
" ∡ p₁ p₂ p₂ = 0",
" p₁ ≠ p₂",
" p₁ -ᵥ p₂ ≠ 0",
" p₃ ≠ p₂",
" p₃ -ᵥ p₂ ≠ 0"
] | [
" ContinuousAt (fun y => ∡ y.1 y.2.1 y.2.2) x",
" (f x).1 ≠ 0",
" (f x).2 ≠ 0",
" ∡ p₁ p₁ p₂ = 0",
" ∡ p₁ p₂ p₂ = 0",
" p₁ ≠ p₂",
" p₁ -ᵥ p₂ ≠ 0"
] |
import Mathlib.Algebra.BigOperators.Associated
import Mathlib.Algebra.Order.Ring.Abs
import Mathlib.Data.Nat.Choose.Sum
import Mathlib.Data.Nat.Choose.Dvd
import Mathlib.Data.Nat.Prime
#align_import number_theory.primorial from "leanprover-community/mathlib"@"0a0ec35061ed9960bf0e7ffb0335f44447b58977"
open Finset
... | Mathlib/NumberTheory/Primorial.lean | 73 | 91 | theorem primorial_le_4_pow (n : ℕ) : n# ≤ 4 ^ n := by |
induction' n using Nat.strong_induction_on with n ihn
cases' n with n; · rfl
rcases n.even_or_odd with (⟨m, rfl⟩ | ho)
· rcases m.eq_zero_or_pos with (rfl | hm)
· decide
calc
(m + m + 1)# = (m + 1 + m)# := by rw [add_right_comm]
_ ≤ (m + 1)# * choose (m + 1 + m) (m + 1) := primorial_add_le ... | [
" (n + 1)# = n#",
" filter Nat.Prime (range (n + 1 + 1)) = filter Nat.Prime (range (n + 1))",
" (n + 1).Prime → Even n",
" (m + n)# = m# * ∏ p ∈ filter Nat.Prime (Ico (m + 1) (m + n + 1)), p",
" Disjoint (filter Nat.Prime (Ico 0 (m + 1))) (filter Nat.Prime (Ico (m + 1) (m + n + 1)))",
" p ∣ (m + n).choose... | [
" (n + 1)# = n#",
" filter Nat.Prime (range (n + 1 + 1)) = filter Nat.Prime (range (n + 1))",
" (n + 1).Prime → Even n",
" (m + n)# = m# * ∏ p ∈ filter Nat.Prime (Ico (m + 1) (m + n + 1)), p",
" Disjoint (filter Nat.Prime (Ico 0 (m + 1))) (filter Nat.Prime (Ico (m + 1) (m + n + 1)))",
" p ∣ (m + n).choose... |
import Mathlib.Order.CompleteLattice
import Mathlib.Order.GaloisConnection
import Mathlib.Data.Set.Lattice
import Mathlib.Tactic.AdaptationNote
#align_import data.rel from "leanprover-community/mathlib"@"706d88f2b8fdfeb0b22796433d7a6c1a010af9f2"
variable {α β γ : Type*}
def Rel (α β : Type*) :=
α → β → Prop --... | Mathlib/Data/Rel.lean | 126 | 128 | theorem comp_right_bot (r : Rel α β) : r • (⊥ : Rel β γ) = ⊥ := by |
ext x y
simp [comp, Bot.bot]
| [
" r.inv.inv = r",
" r.inv.inv x y ↔ r x y",
" r.inv.codom = r.dom",
" x ∈ r.inv.codom ↔ x ∈ r.dom",
" r.inv.dom = r.codom",
" x ∈ r.inv.dom ↔ x ∈ r.codom",
" (r • s) • t = r • s • t",
" (fun x z => ∃ y, (∃ y_1, r x y_1 ∧ s y_1 y) ∧ t y z) = fun x z => ∃ y, r x y ∧ ∃ y_1, s y y_1 ∧ t y_1 z",
" (∃ y, ... | [
" r.inv.inv = r",
" r.inv.inv x y ↔ r x y",
" r.inv.codom = r.dom",
" x ∈ r.inv.codom ↔ x ∈ r.dom",
" r.inv.dom = r.codom",
" x ∈ r.inv.dom ↔ x ∈ r.codom",
" (r • s) • t = r • s • t",
" (fun x z => ∃ y, (∃ y_1, r x y_1 ∧ s y_1 y) ∧ t y z) = fun x z => ∃ y, r x y ∧ ∃ y_1, s y y_1 ∧ t y_1 z",
" (∃ y, ... |
import Mathlib.LinearAlgebra.Matrix.Reindex
import Mathlib.LinearAlgebra.Matrix.ToLin
#align_import linear_algebra.matrix.basis from "leanprover-community/mathlib"@"6c263e4bfc2e6714de30f22178b4d0ca4d149a76"
noncomputable section
open LinearMap Matrix Set Submodule
open Matrix
section BasisToMatrix
variable {ι... | Mathlib/LinearAlgebra/Matrix/Basis.lean | 66 | 69 | theorem toMatrix_eq_toMatrix_constr [Fintype ι] [DecidableEq ι] (v : ι → M) :
e.toMatrix v = LinearMap.toMatrix e e (e.constr ℕ v) := by |
ext
rw [Basis.toMatrix_apply, LinearMap.toMatrix_apply, Basis.constr_basis]
| [
" e.toMatrix v = (LinearMap.toMatrix e e) ((e.constr ℕ) v)",
" e.toMatrix v i✝ j✝ = (LinearMap.toMatrix e e) ((e.constr ℕ) v) i✝ j✝"
] | [] |
import Mathlib.RingTheory.LocalProperties
import Mathlib.RingTheory.Localization.InvSubmonoid
#align_import ring_theory.ring_hom.finite_type from "leanprover-community/mathlib"@"64fc7238fb41b1a4f12ff05e3d5edfa360dd768c"
namespace RingHom
open scoped Pointwise
theorem finiteType_stableUnderComposition : StableUn... | Mathlib/RingTheory/RingHom/FiniteType.lean | 29 | 35 | theorem finiteType_holdsForLocalizationAway : HoldsForLocalizationAway @FiniteType := by |
introv R _
suffices Algebra.FiniteType R S by
rw [RingHom.FiniteType]
convert this; ext;
rw [Algebra.smul_def]; rfl
exact IsLocalization.finiteType_of_monoid_fg (Submonoid.powers r) S
| [
" StableUnderComposition @FiniteType",
" (g.comp f).FiniteType",
" HoldsForLocalizationAway @FiniteType",
" (algebraMap R S).FiniteType",
" Algebra.FiniteType R S",
" (algebraMap R S).toAlgebra = inst✝¹",
" (let_fun I := (algebraMap R S).toAlgebra;\n r✝ • x✝) =\n r✝ • x✝",
" (let_fun I := (algeb... | [
" StableUnderComposition @FiniteType",
" (g.comp f).FiniteType"
] |
import Mathlib.Analysis.Calculus.ContDiff.Basic
import Mathlib.Analysis.Calculus.ParametricIntegral
import Mathlib.MeasureTheory.Constructions.Prod.Integral
import Mathlib.MeasureTheory.Function.LocallyIntegrable
import Mathlib.MeasureTheory.Group.Integral
import Mathlib.MeasureTheory.Group.Prod
import Mathlib.Measure... | Mathlib/Analysis/Convolution.lean | 131 | 136 | theorem _root_.HasCompactSupport.convolution_integrand_bound_right_of_subset
(hcg : HasCompactSupport g) (hg : Continuous g)
{x t : G} {s u : Set G} (hx : x ∈ s) (hu : -tsupport g + s ⊆ u) :
‖L (f t) (g (x - t))‖ ≤ u.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i, ‖g i‖) t := by |
refine convolution_integrand_bound_right_of_le_of_subset _ (fun i => ?_) hx hu
exact le_ciSup (hg.norm.bddAbove_range_of_hasCompactSupport hcg.norm) _
| [
" ‖(L (f t)) (g (x - t))‖ ≤ u.indicator (fun t => ‖L‖ * ‖f t‖ * C) t",
" (fun t => ‖(L (f t)) (g (x - t))‖) t ≤ ‖L‖ * ‖f t‖ * C",
" (fun t => ‖(L (f t)) (g (x - t))‖) t ≤ 0",
" x - t ∉ support g",
" t ∈ -tsupport g + s",
" (fun x x_1 => x + x_1) (-(x - t)) x = t",
" ‖(L (f t)) (g (x - t))‖ ≤ u.indicator... | [
" ‖(L (f t)) (g (x - t))‖ ≤ u.indicator (fun t => ‖L‖ * ‖f t‖ * C) t",
" (fun t => ‖(L (f t)) (g (x - t))‖) t ≤ ‖L‖ * ‖f t‖ * C",
" (fun t => ‖(L (f t)) (g (x - t))‖) t ≤ 0",
" x - t ∉ support g",
" t ∈ -tsupport g + s",
" (fun x x_1 => x + x_1) (-(x - t)) x = t"
] |
import Mathlib.Analysis.InnerProductSpace.Projection
import Mathlib.Analysis.NormedSpace.Dual
import Mathlib.Analysis.NormedSpace.Star.Basic
#align_import analysis.inner_product_space.dual from "leanprover-community/mathlib"@"46b633fd842bef9469441c0209906f6dddd2b4f5"
noncomputable section
open scoped Classical
o... | Mathlib/Analysis/InnerProductSpace/Dual.lean | 157 | 159 | theorem toDual_symm_apply {x : E} {y : NormedSpace.Dual 𝕜 E} : ⟪(toDual 𝕜 E).symm y, x⟫ = y x := by |
rw [← toDual_apply]
simp only [LinearIsometryEquiv.apply_symm_apply]
| [
" x = y",
" (toDualMap 𝕜 E) x = (toDualMap 𝕜 E) y",
" ∀ (i : ι), ↑((toDualMap 𝕜 E) x) (b i) = ↑((toDualMap 𝕜 E) y) (b i)",
" ↑((toDualMap 𝕜 E) x) (b i) = ↑((toDualMap 𝕜 E) y) (b i)",
" ((toDualMap 𝕜 E) x) (b i) = ((toDualMap 𝕜 E) y) (b i)",
" ⟪x, b i⟫_𝕜 = ⟪y, b i⟫_𝕜",
" (starRingEnd 𝕜) ⟪b i, ... | [
" x = y",
" (toDualMap 𝕜 E) x = (toDualMap 𝕜 E) y",
" ∀ (i : ι), ↑((toDualMap 𝕜 E) x) (b i) = ↑((toDualMap 𝕜 E) y) (b i)",
" ↑((toDualMap 𝕜 E) x) (b i) = ↑((toDualMap 𝕜 E) y) (b i)",
" ((toDualMap 𝕜 E) x) (b i) = ((toDualMap 𝕜 E) y) (b i)",
" ⟪x, b i⟫_𝕜 = ⟪y, b i⟫_𝕜",
" (starRingEnd 𝕜) ⟪b i, ... |
import Mathlib.Algebra.Group.NatPowAssoc
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Algebra.Polynomial.Induction
import Mathlib.Algebra.Polynomial.Eval
namespace Polynomial
section MulActionWithZero
variable {R : Type*} [Semiring R] (r : R) (p : R[X]) {S : Type*} [AddCommMonoid S] [Pow S ℕ]
[Mu... | Mathlib/Algebra/Polynomial/Smeval.lean | 69 | 74 | theorem eval₂_eq_smeval (R : Type*) [Semiring R] {S : Type*} [Semiring S] (f : R →+* S) (p : R[X])
(x: S) : letI : Module R S := RingHom.toModule f
p.eval₂ f x = p.smeval x := by |
letI : Module R S := RingHom.toModule f
rw [smeval_eq_sum, eval₂_eq_sum]
rfl
| [
" p.smeval x = p.sum (smul_pow x)",
" (C r).smeval x = r • x ^ 0",
" ((monomial n) r).smeval x = r • x ^ n",
" eval r p = p.smeval r",
" (p.sum fun e a => a * r ^ e) = p.sum (smul_pow r)",
" eval₂ f x p = p.smeval x",
" (p.sum fun e a => f a * x ^ e) = p.sum (smul_pow x)"
] | [
" p.smeval x = p.sum (smul_pow x)",
" (C r).smeval x = r • x ^ 0",
" ((monomial n) r).smeval x = r • x ^ n",
" eval r p = p.smeval r",
" (p.sum fun e a => a * r ^ e) = p.sum (smul_pow r)"
] |
import Mathlib.MeasureTheory.Integral.SetIntegral
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Measure.Haar.Unique
#align_import measure_theory.measure.lebesgue.integral from "leanprover-community/mathlib"@"fd5edc43dc4f10b85abfe544b88f82cf13c5f844"
open Set Filter MeasureTheory... | Mathlib/MeasureTheory/Measure/Lebesgue/Integral.lean | 85 | 91 | theorem integral_comp_neg_Iic {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
(c : ℝ) (f : ℝ → E) : (∫ x in Iic c, f (-x)) = ∫ x in Ioi (-c), f x := by |
have A : MeasurableEmbedding fun x : ℝ => -x :=
(Homeomorph.neg ℝ).closedEmbedding.measurableEmbedding
have := MeasurableEmbedding.setIntegral_map (μ := volume) A f (Ici (-c))
rw [Measure.map_neg_eq_self (volume : Measure ℝ)] at this
simp_rw [← integral_Ici_eq_integral_Ioi, this, neg_preimage, preimage_neg... | [
" ∫ (x : ℝ) in Iic c, f (-x) = ∫ (x : ℝ) in Ioi (-c), f x"
] | [] |
import Mathlib.Data.PFunctor.Univariate.Basic
#align_import data.pfunctor.univariate.M from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
universe u v w
open Nat Function
open List
variable (F : PFunctor.{u})
-- Porting note: the ♯ tactic is never used
-- local prefix:0 "♯" => cast... | Mathlib/Data/PFunctor/Univariate/M.lean | 101 | 115 | theorem truncate_eq_of_agree {n : ℕ} (x : CofixA F n) (y : CofixA F (succ n)) (h : Agree x y) :
truncate y = x := by |
induction n <;> cases x <;> cases y
· rfl
· -- cases' h with _ _ _ _ _ h₀ h₁
cases h
simp only [truncate, Function.comp, true_and_iff, eq_self_iff_true, heq_iff_eq]
-- Porting note: used to be `ext y`
rename_i n_ih a f y h₁
suffices (fun x => truncate (y x)) = f
by simp [this]
funex... | [
" x = CofixA.intro (head' x) (children' x)",
" CofixA.intro a✝¹ a✝ = CofixA.intro (head' (CofixA.intro a✝¹ a✝)) (children' (CofixA.intro a✝¹ a✝))",
" Agree x y",
" Agree (children' x i) (children' y j)",
" Agree (children' (CofixA.intro a✝ x✝) i) (children' (CofixA.intro a✝ x'✝) j)",
" Agree (children' (C... | [
" x = CofixA.intro (head' x) (children' x)",
" CofixA.intro a✝¹ a✝ = CofixA.intro (head' (CofixA.intro a✝¹ a✝)) (children' (CofixA.intro a✝¹ a✝))",
" Agree x y",
" Agree (children' x i) (children' y j)",
" Agree (children' (CofixA.intro a✝ x✝) i) (children' (CofixA.intro a✝ x'✝) j)",
" Agree (children' (C... |
import Mathlib.Combinatorics.SimpleGraph.DegreeSum
import Mathlib.Combinatorics.SimpleGraph.Subgraph
#align_import combinatorics.simple_graph.matching from "leanprover-community/mathlib"@"138448ae98f529ef34eeb61114191975ee2ca508"
universe u
namespace SimpleGraph
variable {V : Type u} {G : SimpleGraph V} (M : Su... | Mathlib/Combinatorics/SimpleGraph/Matching.lean | 122 | 124 | theorem isPerfectMatching_iff_forall_degree {M : Subgraph G} [∀ v, Fintype (M.neighborSet v)] :
M.IsPerfectMatching ↔ ∀ v, M.degree v = 1 := by |
simp [degree_eq_one_iff_unique_adj, isPerfectMatching_iff]
| [
" h.toEdge ⟨v, hv⟩ = ⟨s(v, w), hvw⟩",
" s(v, Exists.choose ⋯) = s(v, w)",
" Exists.choose ⋯ = w",
" Function.Surjective h.toEdge",
" ∃ a, h.toEdge a = ⟨e, he⟩",
" ∃ a, h.toEdge a = ⟨s(x, y), he⟩",
" h.toEdge ⟨v, hv⟩ = h.toEdge ⟨w, hw⟩",
" M.support = M.verts",
" v ∈ M.support",
" M.IsMatching ↔ ∀ ... | [
" h.toEdge ⟨v, hv⟩ = ⟨s(v, w), hvw⟩",
" s(v, Exists.choose ⋯) = s(v, w)",
" Exists.choose ⋯ = w",
" Function.Surjective h.toEdge",
" ∃ a, h.toEdge a = ⟨e, he⟩",
" ∃ a, h.toEdge a = ⟨s(x, y), he⟩",
" h.toEdge ⟨v, hv⟩ = h.toEdge ⟨w, hw⟩",
" M.support = M.verts",
" v ∈ M.support",
" M.IsMatching ↔ ∀ ... |
import Mathlib.CategoryTheory.Generator
import Mathlib.CategoryTheory.Limits.ConeCategory
import Mathlib.CategoryTheory.Limits.Constructions.WeaklyInitial
import Mathlib.CategoryTheory.Limits.FunctorCategory
import Mathlib.CategoryTheory.Subobject.Comma
#align_import category_theory.adjunction.adjoint_functor_theorem... | Mathlib/CategoryTheory/Adjunction/AdjointFunctorTheorems.lean | 69 | 75 | theorem solutionSetCondition_of_isRightAdjoint [G.IsRightAdjoint] : SolutionSetCondition G := by |
intro A
refine
⟨PUnit, fun _ => G.leftAdjoint.obj A, fun _ => (Adjunction.ofIsRightAdjoint G).unit.app A, ?_⟩
intro B h
refine ⟨PUnit.unit, ((Adjunction.ofIsRightAdjoint G).homEquiv _ _).symm h, ?_⟩
rw [← Adjunction.homEquiv_unit, Equiv.apply_symm_apply]
| [
" SolutionSetCondition G",
" ∃ ι B f, ∀ (X : D) (h : A ⟶ G.obj X), ∃ i g, f i ≫ G.map g = h",
" ∀ (X : D) (h : A ⟶ G.obj X), ∃ i g, (fun x => (Adjunction.ofIsRightAdjoint G).unit.app A) i ≫ G.map g = h",
" ∃ i g, (fun x => (Adjunction.ofIsRightAdjoint G).unit.app A) i ≫ G.map g = h",
" (fun x => (Adjunction... | [] |
import Mathlib.MeasureTheory.Group.Measure
assert_not_exists NormedSpace
namespace MeasureTheory
open Measure TopologicalSpace
open scoped ENNReal
variable {G : Type*} [MeasurableSpace G] {μ : Measure G} {g : G}
section MeasurableMul
variable [Group G] [MeasurableMul G]
@[to_additive
"Translating a fu... | Mathlib/MeasureTheory/Group/LIntegral.lean | 54 | 56 | theorem lintegral_div_right_eq_self [IsMulRightInvariant μ] (f : G → ℝ≥0∞) (g : G) :
(∫⁻ x, f (x / g) ∂μ) = ∫⁻ x, f x ∂μ := by |
simp_rw [div_eq_mul_inv, lintegral_mul_right_eq_self f g⁻¹]
| [
" ∫⁻ (x : G), f (g * x) ∂μ = ∫⁻ (x : G), f x ∂μ",
" μ = map (⇑(MeasurableEquiv.mulLeft g)) μ",
" ∫⁻ (x : G), f (x * g) ∂μ = ∫⁻ (x : G), f x ∂μ",
" ∫⁻ (x : G), f x ∂μ = ∫⁻ (a : G), f a ∂map (⇑(MeasurableEquiv.mulRight g)) μ",
" ∫⁻ (x : G), f (x / g) ∂μ = ∫⁻ (x : G), f x ∂μ"
] | [
" ∫⁻ (x : G), f (g * x) ∂μ = ∫⁻ (x : G), f x ∂μ",
" μ = map (⇑(MeasurableEquiv.mulLeft g)) μ",
" ∫⁻ (x : G), f (x * g) ∂μ = ∫⁻ (x : G), f x ∂μ",
" ∫⁻ (x : G), f x ∂μ = ∫⁻ (a : G), f a ∂map (⇑(MeasurableEquiv.mulRight g)) μ"
] |
import Mathlib.Order.Ideal
import Mathlib.Data.Finset.Lattice
#align_import order.countable_dense_linear_order from "leanprover-community/mathlib"@"2705404e701abc6b3127da906f40bae062a169c9"
noncomputable section
open scoped Classical
namespace Order
theorem exists_between_finsets {α : Type*} [LinearOrder α] [... | Mathlib/Order/CountableDenseLinearOrder.lean | 94 | 122 | theorem exists_across [DenselyOrdered β] [NoMinOrder β] [NoMaxOrder β] [Nonempty β]
(f : PartialIso α β) (a : α) :
∃ b : β, ∀ p ∈ f.val, cmp (Prod.fst p) a = cmp (Prod.snd p) b := by |
by_cases h : ∃ b, (a, b) ∈ f.val
· cases' h with b hb
exact ⟨b, fun p hp ↦ f.prop _ hp _ hb⟩
have :
∀ x ∈ (f.val.filter fun p : α × β ↦ p.fst < a).image Prod.snd,
∀ y ∈ (f.val.filter fun p : α × β ↦ a < p.fst).image Prod.snd, x < y := by
intro x hx y hy
rw [Finset.mem_image] at hx hy
rc... | [
" ∃ b, ∀ p ∈ ↑f, cmp p.1 a = cmp p.2 b",
" ∀ x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.1 < a) ↑f),\n ∀ y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.1) ↑f), x < y",
" x < y",
" p.2 < y",
" p.2 < q.2",
" p.1 < q.1",
" ∀ p ∈ ↑f, cmp p.1 a = cmp p.2 b",
" cmp (p1, p2).1 a = cmp (... | [] |
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 | 59 | 61 | theorem foldl_loop_lt (f : α → Fin n → α) (x) (h : m < n) :
foldl.loop n f x m = foldl.loop n f (f x ⟨m, h⟩) (m+1) := by |
rw [foldl.loop, dif_pos 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₂ ... | [
" 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.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 | 133 | 136 | theorem preimage_const (b : β) (s : Set β) [Decidable (b ∈ s)] :
(fun _ : α => b) ⁻¹' s = if b ∈ s then univ else ∅ := by |
split_ifs with hb
exacts [preimage_const_of_mem hb, preimage_const_of_not_mem hb]
| [
" f ⁻¹' s = g ⁻¹' s",
" x ∈ f ⁻¹' s ↔ x ∈ g ⁻¹' s",
" (fun x => b) ⁻¹' s = if b ∈ s then univ else ∅",
" (fun x => b) ⁻¹' s = ∅"
] | [
" f ⁻¹' s = g ⁻¹' s",
" x ∈ f ⁻¹' s ↔ x ∈ g ⁻¹' s"
] |
import Mathlib.Data.Set.Image
import Mathlib.Data.List.GetD
#align_import data.set.list from "leanprover-community/mathlib"@"2ec920d35348cb2d13ac0e1a2ad9df0fdf1a76b4"
open List
variable {α β : Type*} (l : List α)
namespace Set
theorem range_list_map (f : α → β) : range (map f) = { l | ∀ x ∈ l, x ∈ range f } :=... | Mathlib/Data/Set/List.lean | 44 | 48 | theorem range_list_get? : range l.get? = insert none (some '' { x | x ∈ l }) := by |
rw [← range_list_get, ← range_comp]
refine (range_subset_iff.2 fun n => ?_).antisymm (insert_subset_iff.2 ⟨?_, ?_⟩)
exacts [(le_or_lt l.length n).imp get?_eq_none.2 (fun hlt => ⟨⟨_, hlt⟩, (get?_eq_get hlt).symm⟩),
⟨_, get?_eq_none.2 le_rfl⟩, range_subset_iff.2 fun k => ⟨_, get?_eq_get _⟩]
| [
" range (map f) = {l | ∀ x ∈ l, x ∈ range f}",
" l ∈ range (map f)",
" [] ∈ range (map f)",
" a :: l ∈ range (map f)",
" a :: map f l ∈ range (map f)",
" f a :: map f l ∈ range (map f)",
" range (map Subtype.val) = {l | ∀ x ∈ l, x ∈ s}",
" range l.get = {x | x ∈ l}",
" x ∈ range l.get ↔ x ∈ {x | x ∈... | [
" range (map f) = {l | ∀ x ∈ l, x ∈ range f}",
" l ∈ range (map f)",
" [] ∈ range (map f)",
" a :: l ∈ range (map f)",
" a :: map f l ∈ range (map f)",
" f a :: map f l ∈ range (map f)",
" range (map Subtype.val) = {l | ∀ x ∈ l, x ∈ s}",
" range l.get = {x | x ∈ l}",
" x ∈ range l.get ↔ x ∈ {x | x ∈... |
import Mathlib.Algebra.Group.Commute.Units
import Mathlib.Algebra.Group.Invertible.Defs
import Mathlib.Algebra.Group.Hom.Defs
import Mathlib.Logic.Equiv.Defs
#align_import algebra.invertible from "leanprover-community/mathlib"@"722b3b152ddd5e0cf21c0a29787c76596cb6b422"
assert_not_exists MonoidWithZero
assert_not_ex... | Mathlib/Algebra/Group/Invertible/Basic.lean | 77 | 82 | theorem Commute.invOf_left [Monoid α] {a b : α} [Invertible b] (h : Commute b a) :
Commute (⅟ b) a :=
calc
⅟ b * a = ⅟ b * (a * b * ⅟ b) := by | simp [mul_assoc]
_ = ⅟ b * (b * a * ⅟ b) := by rw [h.eq]
_ = a * ⅟ b := by simp [mul_assoc]
| [
" a * ⅟a = 1",
" ⅟a * a = 1",
" a * ⅟b = ⅟b * (b * a * ⅟b)",
" ⅟b * (b * a * ⅟b) = ⅟b * (a * b * ⅟b)",
" ⅟b * (a * b * ⅟b) = ⅟b * a",
" ⅟b * a = ⅟b * (a * b * ⅟b)",
" ⅟b * (a * b * ⅟b) = ⅟b * (b * a * ⅟b)",
" ⅟b * (b * a * ⅟b) = a * ⅟b"
] | [
" a * ⅟a = 1",
" ⅟a * a = 1",
" a * ⅟b = ⅟b * (b * a * ⅟b)",
" ⅟b * (b * a * ⅟b) = ⅟b * (a * b * ⅟b)",
" ⅟b * (a * b * ⅟b) = ⅟b * a"
] |
import Mathlib.SetTheory.Game.Basic
import Mathlib.SetTheory.Ordinal.NaturalOps
#align_import set_theory.game.ordinal from "leanprover-community/mathlib"@"b90e72c7eebbe8de7c8293a80208ea2ba135c834"
universe u
open SetTheory PGame
open scoped NaturalOps PGame
namespace Ordinal
noncomputable def toPGame : Ordin... | Mathlib/SetTheory/Game/Ordinal.lean | 83 | 87 | theorem toPGame_moveLeft_hEq {o : Ordinal} :
have : IsWellOrder o.out.α (· < ·) := isWellOrder_out_lt o
HEq o.toPGame.moveLeft fun x : o.out.α => (typein (· < ·) x).toPGame := by |
rw [toPGame]
rfl
| [
" let_fun this := ⋯;\n o.toPGame = mk (Quotient.out o).α PEmpty.{u_1 + 1} (fun x => (typein (fun x x_1 => x < x_1) x).toPGame) PEmpty.elim",
" o.toPGame.LeftMoves = (Quotient.out o).α",
" o.toPGame.RightMoves = PEmpty.{u_1 + 1}",
" IsEmpty (toPGame 0).LeftMoves",
" IsEmpty (Quotient.out 0).α",
" IsEmpty ... | [
" let_fun this := ⋯;\n o.toPGame = mk (Quotient.out o).α PEmpty.{u_1 + 1} (fun x => (typein (fun x x_1 => x < x_1) x).toPGame) PEmpty.elim",
" o.toPGame.LeftMoves = (Quotient.out o).α",
" o.toPGame.RightMoves = PEmpty.{u_1 + 1}",
" IsEmpty (toPGame 0).LeftMoves",
" IsEmpty (Quotient.out 0).α",
" IsEmpty ... |
import Mathlib.RingTheory.Nilpotent.Basic
import Mathlib.RingTheory.UniqueFactorizationDomain
#align_import algebra.squarefree from "leanprover-community/mathlib"@"00d163e35035c3577c1c79fa53b68de17781ffc1"
variable {R : Type*}
def Squarefree [Monoid R] (r : R) : Prop :=
∀ x : R, x * x ∣ r → IsUnit x
#align sq... | Mathlib/Algebra/Squarefree/Basic.lean | 120 | 126 | theorem squarefree_iff_multiplicity_le_one (r : R) :
Squarefree r ↔ ∀ x : R, multiplicity x r ≤ 1 ∨ IsUnit x := by |
refine forall_congr' fun a => ?_
rw [← sq, pow_dvd_iff_le_multiplicity, or_iff_not_imp_left, not_le, imp_congr _ Iff.rfl]
norm_cast
rw [← one_add_one_eq_two]
simpa using PartENat.add_one_le_iff_lt (PartENat.natCast_ne_top 1)
| [
" ¬Squarefree 0",
" ∃ x, ¬(x * x ∣ 0 → IsUnit x)",
" ¬(0 * 0 ∣ 0 → IsUnit 0)",
" m ≠ 0",
" False",
" Squarefree x",
" IsUnit y",
" n = 0 ∨ n = 1",
" IsUnit x",
" 2 ≤ n",
" x * x ∣ x ^ n",
" x ^ 2 ∣ x ^ n",
" Squarefree r ↔ ∀ (x : R), multiplicity x r ≤ 1 ∨ IsUnit x",
" a * a ∣ r → IsUnit a... | [
" ¬Squarefree 0",
" ∃ x, ¬(x * x ∣ 0 → IsUnit x)",
" ¬(0 * 0 ∣ 0 → IsUnit 0)",
" m ≠ 0",
" False",
" Squarefree x",
" IsUnit y",
" n = 0 ∨ n = 1",
" IsUnit x",
" 2 ≤ n",
" x * x ∣ x ^ n",
" x ^ 2 ∣ x ^ n"
] |
import Mathlib.Tactic.Ring
import Mathlib.Data.PNat.Prime
#align_import data.pnat.xgcd from "leanprover-community/mathlib"@"6afc9b06856ad973f6a2619e3e8a0a8d537a58f2"
open Nat
namespace PNat
structure XgcdType where
wp : ℕ
x : ℕ
y : ℕ
zp : ℕ
ap : ℕ
bp : ℕ
deriving Inhabited
#alig... | Mathlib/Data/PNat/Xgcd.lean | 222 | 224 | theorem flip_isSpecial : (flip u).IsSpecial ↔ u.IsSpecial := by |
dsimp [IsSpecial, flip]
rw [mul_comm u.x, mul_comm u.zp, add_comm u.zp]
| [
" u.v = succ₂ u.vp",
" u.v.1 = (succ₂ u.vp).1",
" u.v.2 = (succ₂ u.vp).2",
" (u.wp + 1) * (u.ap + 1) + u.x * (u.bp + 1) = u.wp + u.x + u.ap + u.wp * u.ap + u.x * u.bp + 1",
" u.y * (u.ap + 1) + (u.zp + 1) * (u.bp + 1) = u.y + u.zp + u.bp + u.y * u.ap + u.zp * u.bp + 1",
" u.IsSpecial ↔ u.IsSpecial'",
" ... | [
" u.v = succ₂ u.vp",
" u.v.1 = (succ₂ u.vp).1",
" u.v.2 = (succ₂ u.vp).2",
" (u.wp + 1) * (u.ap + 1) + u.x * (u.bp + 1) = u.wp + u.x + u.ap + u.wp * u.ap + u.x * u.bp + 1",
" u.y * (u.ap + 1) + (u.zp + 1) * (u.bp + 1) = u.y + u.zp + u.bp + u.y * u.ap + u.zp * u.bp + 1",
" u.IsSpecial ↔ u.IsSpecial'",
" ... |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
#align_import analysis.special_functions.log.monotone from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {x y : ℝ}
theorem log_mul_self_monotoneOn... | Mathlib/Analysis/SpecialFunctions/Log/Monotone.lean | 85 | 88 | theorem log_div_sqrt_antitoneOn : AntitoneOn (fun x : ℝ => log x / √x) { x | exp 2 ≤ x } := by |
simp_rw [sqrt_eq_rpow]
convert @log_div_self_rpow_antitoneOn (1 / 2) (by norm_num)
norm_num
| [
" MonotoneOn (fun x => x.log * x) {x | 1 ≤ x}",
" ∀ ⦃a : ℝ⦄, 1 ≤ a → ∀ ⦃b : ℝ⦄, 1 ≤ b → a ≤ b → a.log * a ≤ b.log * b",
" x.log * x ≤ y.log * y",
" 0 ≤ y.log",
" AntitoneOn (fun x => x.log / x) {x | rexp 1 ≤ x}",
" ∀ ⦃a : ℝ⦄, rexp 1 ≤ a → ∀ ⦃b : ℝ⦄, rexp 1 ≤ b → a ≤ b → b.log / b ≤ a.log / a",
" y.log /... | [
" MonotoneOn (fun x => x.log * x) {x | 1 ≤ x}",
" ∀ ⦃a : ℝ⦄, 1 ≤ a → ∀ ⦃b : ℝ⦄, 1 ≤ b → a ≤ b → a.log * a ≤ b.log * b",
" x.log * x ≤ y.log * y",
" 0 ≤ y.log",
" AntitoneOn (fun x => x.log / x) {x | rexp 1 ≤ x}",
" ∀ ⦃a : ℝ⦄, rexp 1 ≤ a → ∀ ⦃b : ℝ⦄, rexp 1 ≤ b → a ≤ b → b.log / b ≤ a.log / a",
" y.log /... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.