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.Topology.Separation
open Topology Filter Set TopologicalSpace
section Basic
variable {Ξ± : Type*} [TopologicalSpace Ξ±] {C : Set Ξ±}
theorem AccPt.nhds_inter {x : Ξ±} {U : Set Ξ±} (h_acc : AccPt x (π C)) (hU : U β π x) :
AccPt x (π (U β© C)) := by
have : π[β ] x β€ π U := by
rw [le_princ... | Mathlib/Topology/Perfect.lean | 111 | 115 | theorem Preperfect.open_inter {U : Set Ξ±} (hC : Preperfect C) (hU : IsOpen U) :
Preperfect (U β© C) := by |
rintro x β¨xU, xCβ©
apply (hC _ xC).nhds_inter
exact hU.mem_nhds xU
| [
" AccPt x (π (U β© C))",
" π[β ] x β€ π U",
" U β π[β ] x",
" (π[β ] x β π C).NeBot",
" Preperfect C β β x β C, β U β π x, β y β U β© C, y β x",
" Preperfect (U β© C)",
" U β π x"
] | [
" AccPt x (π (U β© C))",
" π[β ] x β€ π U",
" U β π[β ] x",
" (π[β ] x β π C).NeBot",
" Preperfect C β β x β C, β U β π x, β y β U β© C, y β x"
] |
import Mathlib.Data.Matrix.Block
import Mathlib.Data.Matrix.Notation
import Mathlib.Data.Matrix.RowCol
import Mathlib.GroupTheory.GroupAction.Ring
import Mathlib.GroupTheory.Perm.Fin
import Mathlib.LinearAlgebra.Alternating.Basic
#align_import linear_algebra.matrix.determinant from "leanprover-community/mathlib"@"c30... | Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean | 98 | 100 | theorem coe_det_isEmpty [IsEmpty n] : (det : Matrix n n R β R) = Function.const _ 1 := by |
ext
exact det_isEmpty
| [
" M.det = β Ο : Perm n, ββ(sign Ο) * β i : n, M (Ο i) i",
" (diagonal d).det = β i : n, d i",
" β Ο : Perm n, ββ(sign Ο) * β i : n, diagonal d (Ο i) i = β i : n, d i",
" β b β univ, b β 1 β ββ(sign b) * β i : n, diagonal d (b i) i = 0",
" ββ(sign Ο) * β i : n, diagonal d (Ο i) i = 0",
" β i : n, diagonal ... | [
" M.det = β Ο : Perm n, ββ(sign Ο) * β i : n, M (Ο i) i",
" (diagonal d).det = β i : n, d i",
" β Ο : Perm n, ββ(sign Ο) * β i : n, diagonal d (Ο i) i = β i : n, d i",
" β b β univ, b β 1 β ββ(sign b) * β i : n, diagonal d (b i) i = 0",
" ββ(sign Ο) * β i : n, diagonal d (Ο i) i = 0",
" β i : n, diagonal ... |
import Mathlib.LinearAlgebra.LinearPMap
import Mathlib.Topology.Algebra.Module.Basic
#align_import topology.algebra.module.linear_pmap from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Topology
variable {R E F : Type*}
variable [CommRing R] [AddCommGroup E] [AddCommGroup F]
vari... | Mathlib/Topology/Algebra/Module/LinearPMap.lean | 103 | 104 | theorem closure_def {f : E ββ.[R] F} (hf : f.IsClosable) : f.closure = hf.choose := by |
simp [closure, hf]
| [
" g.IsClosable",
" g.graph.topologicalClosure β€ f'.graph",
" g.graph.topologicalClosure β€ f.graph.topologicalClosure",
" g.graph.topologicalClosure = g.graph.topologicalClosure.toLinearPMap.graph",
" β x β g.graph.topologicalClosure, x.1 = 0 β x.2 = 0",
" β! f', f.graph.topologicalClosure = f'.graph",
"... | [
" g.IsClosable",
" g.graph.topologicalClosure β€ f'.graph",
" g.graph.topologicalClosure β€ f.graph.topologicalClosure",
" g.graph.topologicalClosure = g.graph.topologicalClosure.toLinearPMap.graph",
" β x β g.graph.topologicalClosure, x.1 = 0 β x.2 = 0",
" β! f', f.graph.topologicalClosure = f'.graph",
"... |
import Mathlib.NumberTheory.Liouville.Basic
import Mathlib.Topology.Baire.Lemmas
import Mathlib.Topology.Baire.LocallyCompactRegular
import Mathlib.Topology.Instances.Irrational
#align_import number_theory.liouville.residual from "leanprover-community/mathlib"@"32b08ef840dd25ca2e47e035c5da03ce16d2dc3c"
open scope... | Mathlib/NumberTheory/Liouville/Residual.lean | 44 | 55 | theorem setOf_liouville_eq_irrational_inter_iInter_iUnion :
{ x | Liouville x } =
{ x | Irrational x } β© β n : β, β (a : β€) (b : β€) (hb : 1 < b),
ball (a / b) (1 / (b : β) ^ n) := by |
refine Subset.antisymm ?_ ?_
Β· refine subset_inter (fun x hx => hx.irrational) ?_
rw [setOf_liouville_eq_iInter_iUnion]
exact iInter_mono fun n => iUnionβ_mono fun a b => iUnion_mono fun _hb => diff_subset
Β· simp only [inter_iInter, inter_iUnion, setOf_liouville_eq_iInter_iUnion]
refine iInter_mono f... | [
" {x | Liouville x} = β n, β a, β b, β (_ : 1 < b), ball (βa / βb) (1 / βb ^ n) \\ {βa / βb}",
" x β {x | Liouville x} β x β β n, β a, β b, β (_ : 1 < b), ball (βa / βb) (1 / βb ^ n) \\ {βa / βb}",
" IsGΞ΄ {x | Liouville x}",
" IsGΞ΄ (β n, β a, β b, β (_ : 1 < b), ball (βa / βb) (1 / βb ^ n) \\ {βa / βb})",
"... | [
" {x | Liouville x} = β n, β a, β b, β (_ : 1 < b), ball (βa / βb) (1 / βb ^ n) \\ {βa / βb}",
" x β {x | Liouville x} β x β β n, β a, β b, β (_ : 1 < b), ball (βa / βb) (1 / βb ^ n) \\ {βa / βb}",
" IsGΞ΄ {x | Liouville x}",
" IsGΞ΄ (β n, β a, β b, β (_ : 1 < b), ball (βa / βb) (1 / βb ^ n) \\ {βa / βb})",
"... |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Topology.MetricSpace.HausdorffDistance
import Mathlib.Topology.Sets.Compacts
#align_import topology.metric_space.closeds from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open scoped Classical
open Topo... | Mathlib/Topology/MetricSpace/Closeds.lean | 56 | 69 | theorem continuous_infEdist_hausdorffEdist :
Continuous fun p : Ξ± Γ Closeds Ξ± => infEdist p.1 p.2 := by |
refine continuous_of_le_add_edist 2 (by simp) ?_
rintro β¨x, sβ© β¨y, tβ©
calc
infEdist x s β€ infEdist x t + hausdorffEdist (t : Set Ξ±) s :=
infEdist_le_infEdist_add_hausdorffEdist
_ β€ infEdist y t + edist x y + hausdorffEdist (t : Set Ξ±) s :=
(add_le_add_right infEdist_le_infEdist_add_edist _)
... | [
" Continuous fun p => infEdist p.1 βp.2",
" 2 β β€",
" β (x y : Ξ± Γ Closeds Ξ±), infEdist x.1 βx.2 β€ infEdist y.1 βy.2 + 2 * edist x y",
" infEdist (x, s).1 β(x, s).2 β€ infEdist (y, t).1 β(y, t).2 + 2 * edist (x, s) (y, t)",
" infEdist y βt + edist x y + hausdorffEdist βt βs = infEdist y βt + (edist x y + hau... | [] |
import Mathlib.CategoryTheory.Preadditive.Yoneda.Basic
import Mathlib.CategoryTheory.Preadditive.Projective
import Mathlib.Algebra.Category.GroupCat.EpiMono
#align_import category_theory.preadditive.yoneda.projective from "leanprover-community/mathlib"@"f8d8465c3c392a93b9ed226956e26dee00975946"
universe v u
open... | Mathlib/CategoryTheory/Preadditive/Yoneda/Projective.lean | 31 | 39 | theorem projective_iff_preservesEpimorphisms_preadditiveCoyoneda_obj (P : C) :
Projective P β (preadditiveCoyoneda.obj (op P)).PreservesEpimorphisms := by |
rw [projective_iff_preservesEpimorphisms_coyoneda_obj]
refine β¨fun h : (preadditiveCoyoneda.obj (op P) β
forget AddCommGroupCat).PreservesEpimorphisms => ?_, ?_β©
Β· exact Functor.preservesEpimorphisms_of_preserves_of_reflects (preadditiveCoyoneda.obj (op P))
(forget _)
Β· intro
exact (inferInst... | [
" Projective P β (preadditiveCoyoneda.obj { unop := P }).PreservesEpimorphisms",
" (coyoneda.obj { unop := P }).PreservesEpimorphisms β (preadditiveCoyoneda.obj { unop := P }).PreservesEpimorphisms",
" (preadditiveCoyoneda.obj { unop := P }).PreservesEpimorphisms",
" (preadditiveCoyoneda.obj { unop := P }).Pr... | [] |
import Mathlib.LinearAlgebra.FiniteDimensional
import Mathlib.MeasureTheory.Group.Pointwise
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Measure.Haar.Basic
import Mathlib.MeasureTheory.Measure.Doubling
import Mathlib.MeasureTheory.Constructions.BorelSpace.Metric
#align_import measu... | Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean | 95 | 104 | theorem Basis.map_addHaar {ΞΉ E F : Type*} [Fintype ΞΉ] [NormedAddCommGroup E] [NormedAddCommGroup F]
[NormedSpace β E] [NormedSpace β F] [MeasurableSpace E] [MeasurableSpace F] [BorelSpace E]
[BorelSpace F] [SecondCountableTopology F] [SigmaCompactSpace F]
(b : Basis ΞΉ β E) (f : E βL[β] F) :
map f b.addH... |
have : IsAddHaarMeasure (map f b.addHaar) :=
AddEquiv.isAddHaarMeasure_map b.addHaar f.toAddEquiv f.continuous f.symm.continuous
rw [eq_comm, Basis.addHaar_eq_iff, Measure.map_apply f.continuous.measurable
(PositiveCompacts.isCompact _).measurableSet, Basis.coe_parallelepiped, Basis.coe_map]
erw [β image... | [
" (interior { carrier := Icc 0 1, isCompact' := β― }.carrier).Nonempty",
" (interior { carrier := univ.pi fun x => Icc 0 1, isCompact' := β― }.carrier).Nonempty",
" β(Pi.basisFun β ΞΉ).parallelepiped = β(PositiveCompacts.piIcc01 ΞΉ)",
" β(Pi.basisFun β ΞΉ).parallelepiped = uIcc (fun i => 0) fun i => 1",
" (fun i... | [
" (interior { carrier := Icc 0 1, isCompact' := β― }.carrier).Nonempty",
" (interior { carrier := univ.pi fun x => Icc 0 1, isCompact' := β― }.carrier).Nonempty",
" β(Pi.basisFun β ΞΉ).parallelepiped = β(PositiveCompacts.piIcc01 ΞΉ)",
" β(Pi.basisFun β ΞΉ).parallelepiped = uIcc (fun i => 0) fun i => 1",
" (fun i... |
import Mathlib.Data.List.Sublists
import Mathlib.Data.Multiset.Bind
#align_import data.multiset.powerset from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
namespace Multiset
open List
variable {Ξ± : Type*}
-- Porting note (#11215): TODO: Write a more efficient version
def powerset... | Mathlib/Data/Multiset/Powerset.lean | 45 | 46 | theorem powersetAux_perm_powersetAux' {l : List Ξ±} : powersetAux l ~ powersetAux' l := by |
rw [powersetAux_eq_map_coe]; exact (sublists_perm_sublists' _).map _
| [
" β (a : List Ξ±), β¦aβ§ β powersetAux l β β¦aβ§ β€ βl",
" powersetAux l ~ powersetAux' l",
" List.map ofList l.sublists ~ powersetAux' l"
] | [
" β (a : List Ξ±), β¦aβ§ β powersetAux l β β¦aβ§ β€ βl"
] |
import Mathlib.RingTheory.Derivation.Basic
import Mathlib.RingTheory.Ideal.QuotientOperations
#align_import ring_theory.derivation.to_square_zero from "leanprover-community/mathlib"@"b608348ffaeb7f557f2fd46876037abafd326ff3"
section ToSquareZero
universe u v w
variable {R : Type u} {A : Type v} {B : Type w} [Co... | Mathlib/RingTheory/Derivation/ToSquareZero.lean | 106 | 110 | theorem liftOfDerivationToSquareZero_mk_apply (d : Derivation R A I) (x : A) :
Ideal.Quotient.mk I (liftOfDerivationToSquareZero I hI d x) = algebraMap A (B β§Έ I) x := by |
rw [liftOfDerivationToSquareZero_apply, map_add, Ideal.Quotient.eq_zero_iff_mem.mpr (d x).prop,
zero_add]
rfl
| [
" β (c : A), (fβ.toLinearMap - fβ.toLinearMap) c β Submodule.restrictScalars R I",
" (fβ.toLinearMap - fβ.toLinearMap) x β Submodule.restrictScalars R I",
" fβ x - fβ x β I",
" ((Ideal.Quotient.mkβ R I).comp fβ) x = (Ideal.Quotient.mkβ R I) (fβ x)",
" Derivation R A β₯I",
" (Ideal.Quotient.mkβ R I).comp f ... | [
" β (c : A), (fβ.toLinearMap - fβ.toLinearMap) c β Submodule.restrictScalars R I",
" (fβ.toLinearMap - fβ.toLinearMap) x β Submodule.restrictScalars R I",
" fβ x - fβ x β I",
" ((Ideal.Quotient.mkβ R I).comp fβ) x = (Ideal.Quotient.mkβ R I) (fβ x)",
" Derivation R A β₯I",
" (Ideal.Quotient.mkβ R I).comp f ... |
import Mathlib.RingTheory.OrzechProperty
import Mathlib.RingTheory.Ideal.Quotient
import Mathlib.RingTheory.PrincipalIdealDomain
#align_import linear_algebra.invariant_basis_number from "leanprover-community/mathlib"@"5fd3186f1ec30a75d5f65732e3ce5e623382556f"
noncomputable section
open Function
universe u v w
... | Mathlib/LinearAlgebra/InvariantBasisNumber.lean | 167 | 173 | theorem card_le_of_injective' [StrongRankCondition R] {Ξ± Ξ² : Type*} [Fintype Ξ±] [Fintype Ξ²]
(f : (Ξ± ββ R) ββ[R] Ξ² ββ R) (i : Injective f) : Fintype.card Ξ± β€ Fintype.card Ξ² := by |
let P := Finsupp.linearEquivFunOnFinite R R Ξ²
let Q := (Finsupp.linearEquivFunOnFinite R R Ξ±).symm
exact
card_le_of_injective R ((P.toLinearMap.comp f).comp Q.toLinearMap)
((P.injective.comp i).comp Q.injective)
| [
" StrongRankCondition R β β (n : β) (f : (Fin (n + 1) β R) ββ[R] Fin n β R), Β¬Injective βf",
" False",
" n β€ m",
" StrongRankCondition R",
" 0 = update 0 (Fin.last n) 1",
" f 0 = f (update 0 (Fin.last n) 1)",
" f 0 m = f (update 0 (Fin.last n) 1) m",
" Fintype.card Ξ± β€ Fintype.card Ξ²"
] | [
" StrongRankCondition R β β (n : β) (f : (Fin (n + 1) β R) ββ[R] Fin n β R), Β¬Injective βf",
" False",
" n β€ m",
" StrongRankCondition R",
" 0 = update 0 (Fin.last n) 1",
" f 0 = f (update 0 (Fin.last n) 1)",
" f 0 m = f (update 0 (Fin.last n) 1) m",
" Fintype.card Ξ± β€ Fintype.card Ξ²"
] |
import Mathlib.Analysis.Convex.Cone.Basic
import Mathlib.Analysis.InnerProductSpace.Projection
#align_import analysis.convex.cone.dual from "leanprover-community/mathlib"@"915591b2bb3ea303648db07284a161a7f2a9e3d4"
open Set LinearMap
open scoped Classical
open Pointwise
variable {π E F G : Type*}
section Dua... | Mathlib/Analysis/Convex/Cone/InnerDual.lean | 144 | 161 | theorem ConvexCone.pointed_of_nonempty_of_isClosed (K : ConvexCone β H) (ne : (K : Set H).Nonempty)
(hc : IsClosed (K : Set H)) : K.Pointed := by |
obtain β¨x, hxβ© := ne
let f : β β H := (Β· β’ x)
-- f (0, β) is a subset of K
have fI : f '' Set.Ioi 0 β (K : Set H) := by
rintro _ β¨_, h, rflβ©
exact K.smul_mem (Set.mem_Ioi.1 h) hx
-- closure of f (0, β) is a subset of K
have clf : closure (f '' Set.Ioi 0) β (K : Set H) := hc.closure_subset_iff.2 fI
... | [
" 0 β€ βͺx, c β’ yβ«_β",
" 0 β€ c * βͺx, yβ«_β",
" 0 β€ βͺx, u + vβ«_β",
" 0 β€ βͺx, uβ«_β + βͺx, vβ«_β",
" univ.innerDualCone = 0",
" βuniv.innerDualCone = β0",
" β x β univ.innerDualCone, x = 0",
" x = 0",
" 0 β€ βͺx, 0β«_β",
" (insert x s).innerDualCone = {x}.innerDualCone β s.innerDualCone",
" (β i, f i).inne... | [
" 0 β€ βͺx, c β’ yβ«_β",
" 0 β€ c * βͺx, yβ«_β",
" 0 β€ βͺx, u + vβ«_β",
" 0 β€ βͺx, uβ«_β + βͺx, vβ«_β",
" univ.innerDualCone = 0",
" βuniv.innerDualCone = β0",
" β x β univ.innerDualCone, x = 0",
" x = 0",
" 0 β€ βͺx, 0β«_β",
" (insert x s).innerDualCone = {x}.innerDualCone β s.innerDualCone",
" (β i, f i).inne... |
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Data.Finset.Option
#align_import algebra.big_operators.option from "leanprover-community/mathlib"@"008205aa645b3f194c1da47025c5f110c8406eab"
open Function
namespace Finset
variable {Ξ± M : Type*} [CommMonoid M]
@[to_additive (attr := simp)]
| Mathlib/Algebra/BigOperators/Option.lean | 25 | 26 | theorem prod_insertNone (f : Option Ξ± β M) (s : Finset Ξ±) :
β x β insertNone s, f x = f none * β x β s, f (some x) := by | simp [insertNone]
| [
" β x β insertNone s, f x = f none * β x β s, f (some x)"
] | [] |
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse
#align_import analysis.special_functions.complex.arg from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba144755cd1"
open Filter Metric Set
open scoped ComplexConjugate Real To... | Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean | 76 | 83 | theorem abs_eq_one_iff (z : β) : abs z = 1 β β ΞΈ : β, exp (ΞΈ * I) = z := by |
refine β¨fun hz => β¨arg z, ?_β©, ?_β©
Β· calc
exp (arg z * I) = abs z * exp (arg z * I) := by rw [hz, ofReal_one, one_mul]
_ = z := abs_mul_exp_arg_mul_I z
Β· rintro β¨ΞΈ, rflβ©
exact Complex.abs_exp_ofReal_mul_I ΞΈ
| [
" x.arg.sin = x.im / abs x",
" (if 0 β€ x.re then (x.im / abs x).arcsin\n else if 0 β€ x.im then ((-x).im / abs x).arcsin + Ο else ((-x).im / abs x).arcsin - Ο).sin =\n x.im / abs x",
" (x.im / abs x).arcsin.sin = x.im / abs x",
" (((-x).im / abs x).arcsin + Ο).sin = x.im / abs x",
" (((-x).im / abs x... | [
" x.arg.sin = x.im / abs x",
" (if 0 β€ x.re then (x.im / abs x).arcsin\n else if 0 β€ x.im then ((-x).im / abs x).arcsin + Ο else ((-x).im / abs x).arcsin - Ο).sin =\n x.im / abs x",
" (x.im / abs x).arcsin.sin = x.im / abs x",
" (((-x).im / abs x).arcsin + Ο).sin = x.im / abs x",
" (((-x).im / abs x... |
import Mathlib.MeasureTheory.Constructions.Prod.Basic
import Mathlib.MeasureTheory.Group.Measure
import Mathlib.Topology.Constructions
#align_import measure_theory.constructions.pi from "leanprover-community/mathlib"@"fd5edc43dc4f10b85abfe544b88f82cf13c5f844"
noncomputable section
open Function Set MeasureTheory... | Mathlib/MeasureTheory/Constructions/Pi.lean | 197 | 201 | theorem pi_pi_le (m : β i, OuterMeasure (Ξ± i)) (s : β i, Set (Ξ± i)) :
OuterMeasure.pi m (pi univ s) β€ β i, m i (s i) := by |
rcases (pi univ s).eq_empty_or_nonempty with h | h
Β· simp [h]
exact (boundedBy_le _).trans_eq (piPremeasure_pi h)
| [
" IsPiSystem (univ.pi '' univ.pi C)",
" univ.pi sβ β© univ.pi sβ β univ.pi '' univ.pi C",
" (univ.pi fun i => sβ i β© sβ i) β univ.pi '' univ.pi C",
" piPremeasure m (univ.pi s) = β i : ΞΉ, (m i) (s i)",
" (m i) (s i) = 0",
" piPremeasure m (univ.pi fun i => eval i '' s) = piPremeasure m s",
" β i : ΞΉ, (m ... | [
" IsPiSystem (univ.pi '' univ.pi C)",
" univ.pi sβ β© univ.pi sβ β univ.pi '' univ.pi C",
" (univ.pi fun i => sβ i β© sβ i) β univ.pi '' univ.pi C",
" piPremeasure m (univ.pi s) = β i : ΞΉ, (m i) (s i)",
" (m i) (s i) = 0",
" piPremeasure m (univ.pi fun i => eval i '' s) = piPremeasure m s",
" β i : ΞΉ, (m ... |
import Mathlib.Analysis.NormedSpace.Star.Basic
import Mathlib.Analysis.NormedSpace.Spectrum
import Mathlib.Analysis.SpecialFunctions.Exponential
import Mathlib.Algebra.Star.StarAlgHom
#align_import analysis.normed_space.star.spectrum from "leanprover-community/mathlib"@"f0c8bf9245297a541f468be517f1bde6195105e9"
l... | Mathlib/Analysis/NormedSpace/Star/Spectrum.lean | 31 | 41 | theorem unitary.spectrum_subset_circle (u : unitary E) :
spectrum π (u : E) β Metric.sphere 0 1 := by |
nontriviality E
refine fun k hk => mem_sphere_zero_iff_norm.mpr (le_antisymm ?_ ?_)
Β· simpa only [CstarRing.norm_coe_unitary u] using norm_le_norm_of_mem hk
Β· rw [β unitary.val_toUnits_apply u] at hk
have hnk := ne_zero_of_mem_of_unit hk
rw [β inv_inv (unitary.toUnits u), β spectrum.map_inv, Set.mem_in... | [
" spectrum π βu β Metric.sphere 0 1",
" βkβ β€ 1",
" 1 β€ βkβ",
" βkββ»ΒΉ β€ ββ(toUnits u)β»ΒΉβ"
] | [] |
import Mathlib.Analysis.NormedSpace.Banach
import Mathlib.Topology.Algebra.Module.FiniteDimension
#align_import analysis.normed_space.complemented from "leanprover-community/mathlib"@"3397560e65278e5f31acefcdea63138bd53d1cd4"
variable {π E F G : Type*} [NontriviallyNormedField π] [NormedAddCommGroup E] [NormedS... | Mathlib/Analysis/NormedSpace/Complemented.lean | 39 | 43 | theorem ker_closedComplemented_of_finiteDimensional_range (f : E βL[π] F)
[FiniteDimensional π (range f)] : (ker f).ClosedComplemented := by |
set f' : E βL[π] range f := f.codRestrict _ (LinearMap.mem_range_self (f : E ββ[π] F))
rcases f'.exists_right_inverse_of_surjective (f : E ββ[π] F).range_rangeRestrict with β¨g, hgβ©
simpa only [f', ker_codRestrict] using f'.closedComplemented_ker_of_rightInverse g (ext_iff.1 hg)
| [
" (ker f).ClosedComplemented"
] | [] |
import Mathlib.Combinatorics.Quiver.Basic
import Mathlib.Combinatorics.Quiver.Path
#align_import combinatorics.quiver.cast from "leanprover-community/mathlib"@"fc2ed6f838ce7c9b7c7171e58d78eaf7b438fb0e"
universe v vβ vβ u uβ uβ
variable {U : Type*} [Quiver.{u + 1} U]
namespace Quiver
def Hom.cast {u v u' v... | Mathlib/Combinatorics/Quiver/Cast.lean | 130 | 133 | theorem Path.cast_cons {u v w u' w' : U} (p : Path u v) (e : v βΆ w) (hu : u = u') (hw : w = w') :
(p.cons e).cast hu hw = (p.cast hu rfl).cons (e.cast rfl hw) := by |
subst_vars
rfl
| [
" (u βΆ v) = (u' βΆ v')",
" cast hu hv e = _root_.cast β― e",
" cast β― β― e = _root_.cast β― e",
" cast hu' hv' (cast hu hv e) = cast β― β― e",
" cast β― β― (cast β― β― e) = cast β― β― e",
" HEq (cast hu hv e) e",
" HEq (cast β― β― e) e",
" cast hu hv e = e' β HEq e e'",
" _root_.cast β― e = e' β HEq e e'",
" e' ... | [
" (u βΆ v) = (u' βΆ v')",
" cast hu hv e = _root_.cast β― e",
" cast β― β― e = _root_.cast β― e",
" cast hu' hv' (cast hu hv e) = cast β― β― e",
" cast β― β― (cast β― β― e) = cast β― β― e",
" HEq (cast hu hv e) e",
" HEq (cast β― β― e) e",
" cast hu hv e = e' β HEq e e'",
" _root_.cast β― e = e' β HEq e e'",
" e' ... |
import Mathlib.Data.Matrix.Basic
import Mathlib.LinearAlgebra.Matrix.Trace
#align_import data.matrix.basis from "leanprover-community/mathlib"@"320df450e9abeb5fc6417971e75acb6ae8bc3794"
variable {l m n : Type*}
variable {R Ξ± : Type*}
namespace Matrix
open Matrix
variable [DecidableEq l] [DecidableEq m] [Decida... | Mathlib/Data/Matrix/Basis.lean | 57 | 63 | theorem mulVec_stdBasisMatrix [Fintype m] (i : n) (j : m) (c : Ξ±) (x : m β Ξ±) :
mulVec (stdBasisMatrix i j c) x = Function.update (0 : n β Ξ±) i (c * x j) := by |
ext i'
simp [stdBasisMatrix, mulVec, dotProduct]
rcases eq_or_ne i i' with rfl|h
Β· simp
simp [h, h.symm]
| [
" r β’ stdBasisMatrix i j a = stdBasisMatrix i j (r β’ a)",
" (r β’ fun i' j' => if i = i' β§ j = j' then a else 0) = fun i' j' => if i = i' β§ j = j' then r β’ a else 0",
" (r β’ fun i' j' => if i = i' β§ j = j' then a else 0) iβ jβ = if i = iβ β§ j = jβ then r β’ a else 0",
" stdBasisMatrix i j 0 = 0",
" (fun i' j'... | [
" r β’ stdBasisMatrix i j a = stdBasisMatrix i j (r β’ a)",
" (r β’ fun i' j' => if i = i' β§ j = j' then a else 0) = fun i' j' => if i = i' β§ j = j' then r β’ a else 0",
" (r β’ fun i' j' => if i = i' β§ j = j' then a else 0) iβ jβ = if i = iβ β§ j = jβ then r β’ a else 0",
" stdBasisMatrix i j 0 = 0",
" (fun i' j'... |
import Mathlib.Analysis.Convex.Cone.Basic
import Mathlib.Data.Real.Archimedean
import Mathlib.LinearAlgebra.LinearPMap
#align_import analysis.convex.cone.basic from "leanprover-community/mathlib"@"915591b2bb3ea303648db07284a161a7f2a9e3d4"
open Set LinearMap
variable {π E F G : Type*}
variable [AddCommGroup E... | Mathlib/Analysis/Convex/Cone/Extension.lean | 64 | 112 | theorem step (nonneg : β x : f.domain, (x : E) β s β 0 β€ f x)
(dense : β y, β x : f.domain, (x : E) + y β s) (hdom : f.domain β β€) :
β g, f < g β§ β x : g.domain, (x : E) β s β 0 β€ g x := by |
obtain β¨y, -, hyβ© : β y β β€, y β f.domain := SetLike.exists_of_lt (lt_top_iff_ne_top.2 hdom)
obtain β¨c, le_c, c_leβ© :
β c, (β x : f.domain, -(x : E) - y β s β f x β€ c) β§
β x : f.domain, (x : E) + y β s β c β€ f x := by
set Sp := f '' { x : f.domain | (x : E) + y β s }
set Sn := f '' { x : f.do... | [
" β g, f < g β§ β (x : β₯g.domain), βx β s β 0 β€ βg x",
" β c, (β (x : β₯f.domain), -βx - y β s β βf x β€ c) β§ β (x : β₯f.domain), βx + y β s β c β€ βf x",
" (upperBounds Sn β© lowerBounds Sp).Nonempty",
" {x | -βx - y β s}.Nonempty",
" β x β Sn, β y β Sp, x β€ y",
" βf xn β€ βf xp",
" f < f.supSpanSingleton y (... | [] |
import Mathlib.Algebra.Group.Defs
import Mathlib.Algebra.Group.Prod
import Mathlib.Data.PNat.Basic
import Mathlib.GroupTheory.GroupAction.Prod
variable {M : Type*}
class PNatPowAssoc (M : Type*) [Mul M] [Pow M β+] : Prop where
protected ppow_add : β (k n : β+) (x : M), x ^ (k + n) = x ^ k * x ^ n
prote... | Mathlib/Algebra/Group/PNatPowAssoc.lean | 60 | 62 | theorem ppow_mul_assoc (k m n : β+) (x : M) :
(x ^ k * x ^ m) * x ^ n = x ^ k * (x ^ m * x ^ n) := by |
simp only [β ppow_add, add_assoc]
| [
" x ^ k * x ^ m * x ^ n = x ^ k * (x ^ m * x ^ n)"
] | [] |
import Mathlib.Geometry.Euclidean.Angle.Oriented.Affine
import Mathlib.Geometry.Euclidean.Angle.Unoriented.RightAngle
#align_import geometry.euclidean.angle.oriented.right_angle from "leanprover-community/mathlib"@"46b633fd842bef9469441c0209906f6dddd2b4f5"
noncomputable section
open scoped EuclideanGeometry
ope... | Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean | 638 | 642 | theorem cos_oangle_right_of_oangle_eq_pi_div_two {pβ pβ pβ : P} (h : β‘ pβ pβ pβ = β(Ο / 2)) :
Real.Angle.cos (β‘ pβ pβ pβ) = dist pβ pβ / dist pβ pβ := by |
have hs : (β‘ pβ pβ pβ).sign = 1 := by rw [oangle_rotate_sign, h, Real.Angle.sign_coe_pi_div_two]
rw [oangle_eq_angle_of_sign_eq_one hs, Real.Angle.cos_coe,
cos_angle_of_angle_eq_pi_div_two (angle_eq_pi_div_two_of_oangle_eq_pi_div_two h)]
| [
" β‘ pβ pβ pβ = β(dist pβ pβ / dist pβ pβ).arccos",
" (β‘ pβ pβ pβ).sign = 1",
" β‘ pβ pβ pβ = β(dist pβ pβ / dist pβ pβ).arccos",
" (β‘ pβ pβ pβ).sign = 1",
" β‘ pβ pβ pβ = β(dist pβ pβ / dist pβ pβ).arcsin",
" β‘ pβ pβ pβ = β(dist pβ pβ / dist pβ pβ).arcsin",
" β‘ pβ pβ pβ = β(dist pβ pβ / dist pβ pβ).arctan... | [
" β‘ pβ pβ pβ = β(dist pβ pβ / dist pβ pβ).arccos",
" (β‘ pβ pβ pβ).sign = 1",
" β‘ pβ pβ pβ = β(dist pβ pβ / dist pβ pβ).arccos",
" (β‘ pβ pβ pβ).sign = 1",
" β‘ pβ pβ pβ = β(dist pβ pβ / dist pβ pβ).arcsin",
" β‘ pβ pβ pβ = β(dist pβ pβ / dist pβ pβ).arcsin",
" β‘ pβ pβ pβ = β(dist pβ pβ / dist pβ pβ).arctan... |
import Mathlib.Probability.Kernel.Basic
import Mathlib.MeasureTheory.Constructions.Prod.Basic
import Mathlib.MeasureTheory.Integral.DominatedConvergence
#align_import probability.kernel.measurable_integral from "leanprover-community/mathlib"@"28b2a92f2996d28e580450863c130955de0ed398"
open MeasureTheory Probabilit... | Mathlib/Probability/Kernel/MeasurableIntegral.lean | 42 | 99 | theorem measurable_kernel_prod_mk_left_of_finite {t : Set (Ξ± Γ Ξ²)} (ht : MeasurableSet t)
(hΞΊs : β a, IsFiniteMeasure (ΞΊ a)) : Measurable fun a => ΞΊ a (Prod.mk a β»ΒΉ' t) := by |
-- `t` is a measurable set in the product `Ξ± Γ Ξ²`: we use that the product Ο-algebra is generated
-- by boxes to prove the result by induction.
-- Porting note: added motive
refine MeasurableSpace.induction_on_inter
(C := fun t => Measurable fun a => ΞΊ a (Prod.mk a β»ΒΉ' t))
generateFrom_prod.symm isPiSy... | [
" Measurable fun a => (ΞΊ a) (Prod.mk a β»ΒΉ' t)",
" (fun t => Measurable fun a => (ΞΊ a) (Prod.mk a β»ΒΉ' t)) β
",
" β t β image2 (fun x x_1 => x ΓΛ’ x_1) {s | MeasurableSet s} {t | MeasurableSet t},\n (fun t => Measurable fun a => (ΞΊ a) (Prod.mk a β»ΒΉ' t)) t",
" Measurable fun a => (ΞΊ a) (Prod.mk a β»ΒΉ' t')",
" ... | [] |
import Mathlib.AlgebraicGeometry.Properties
#align_import algebraic_geometry.function_field from "leanprover-community/mathlib"@"d39590fc8728fbf6743249802486f8c91ffe07bc"
-- Explicit universe annotations were used in this file to improve perfomance #12737
set_option linter.uppercaseLean3 false
universe u v
open... | Mathlib/AlgebraicGeometry/FunctionField.lean | 83 | 93 | theorem genericPoint_eq_of_isOpenImmersion {X Y : Scheme} (f : X βΆ Y) [H : IsOpenImmersion f]
[hX : IrreducibleSpace X.carrier] [IrreducibleSpace Y.carrier] :
f.1.base (genericPoint X.carrier : _) = (genericPoint Y.carrier : _) := by |
apply ((genericPoint_spec Y).eq _).symm
convert (genericPoint_spec X.carrier).image (show Continuous f.1.base by continuity)
symm
rw [eq_top_iff, Set.top_eq_univ, Set.top_eq_univ]
convert subset_closure_inter_of_isPreirreducible_of_isOpen _ H.base_open.isOpen_range _
Β· rw [Set.univ_inter, Set.image_univ]
... | [
" (β€ β© βU).Nonempty",
" Field βX.functionField",
" IsUnit a β¨ a = 0",
" IsUnit ((X.presheaf.germ β¨genericPoint ββX.toPresheafedSpace, mβ©) s) β¨\n (X.presheaf.germ β¨genericPoint ββX.toPresheafedSpace, mβ©) s = 0",
" Β¬(X.presheaf.germ β¨genericPoint ββX.toPresheafedSpace, mβ©) s =\n (X.presheaf.germ β¨ge... | [
" (β€ β© βU).Nonempty",
" Field βX.functionField",
" IsUnit a β¨ a = 0",
" IsUnit ((X.presheaf.germ β¨genericPoint ββX.toPresheafedSpace, mβ©) s) β¨\n (X.presheaf.germ β¨genericPoint ββX.toPresheafedSpace, mβ©) s = 0",
" Β¬(X.presheaf.germ β¨genericPoint ββX.toPresheafedSpace, mβ©) s =\n (X.presheaf.germ β¨ge... |
import Mathlib.GroupTheory.Coxeter.Length
import Mathlib.Data.ZMod.Parity
namespace CoxeterSystem
open List Matrix Function
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
local prefi... | Mathlib/GroupTheory/Coxeter/Inversion.lean | 82 | 86 | theorem odd_length : Odd (β t) := by |
suffices cs.lengthParity t = Multiplicative.ofAdd 1 by
simpa [lengthParity_eq_ofAdd_length, ZMod.eq_one_iff_odd]
rcases ht with β¨w, i, rflβ©
simp [lengthParity_simple]
| [
" cs.IsReflection (cs.simple i)",
" cs.simple i = 1 * cs.simple i * 1β»ΒΉ",
" t ^ 2 = 1",
" (w * cs.simple i * wβ»ΒΉ) ^ 2 = 1",
" t * t = 1",
" w * cs.simple i * wβ»ΒΉ * (w * cs.simple i * wβ»ΒΉ) = 1",
" tβ»ΒΉ = t",
" (w * cs.simple i * wβ»ΒΉ)β»ΒΉ = w * cs.simple i * wβ»ΒΉ",
" cs.IsReflection tβ»ΒΉ",
" Odd (cs.leng... | [
" cs.IsReflection (cs.simple i)",
" cs.simple i = 1 * cs.simple i * 1β»ΒΉ",
" t ^ 2 = 1",
" (w * cs.simple i * wβ»ΒΉ) ^ 2 = 1",
" t * t = 1",
" w * cs.simple i * wβ»ΒΉ * (w * cs.simple i * wβ»ΒΉ) = 1",
" tβ»ΒΉ = t",
" (w * cs.simple i * wβ»ΒΉ)β»ΒΉ = w * cs.simple i * wβ»ΒΉ",
" cs.IsReflection tβ»ΒΉ"
] |
import Mathlib.LinearAlgebra.Dimension.Constructions
import Mathlib.LinearAlgebra.Dimension.Finite
universe u v
open Function Set Cardinal
variable {R} {M Mβ Mβ Mβ : Type u} {M' : Type v} [Ring R]
variable [AddCommGroup M] [AddCommGroup Mβ] [AddCommGroup Mβ] [AddCommGroup Mβ] [AddCommGroup M']
variable [Module R M... | Mathlib/LinearAlgebra/Dimension/RankNullity.lean | 127 | 132 | theorem exists_linearIndependent_snoc_of_lt_rank [StrongRankCondition R] {n : β} {v : Fin n β M}
(hv : LinearIndependent R v) (h : n < Module.rank R M) :
β (x : M), LinearIndependent R (Fin.snoc v x) := by |
simp only [Fin.snoc_eq_cons_rotate]
have β¨x, hxβ© := exists_linearIndependent_cons_of_lt_rank hv h
exact β¨x, hx.comp _ (finRotate _).injectiveβ©
| [
" Nontrivial R",
" False",
" lift.{u, v} (Module.rank R β₯(LinearMap.range f)) + lift.{v, u} (Module.rank R β₯(LinearMap.ker f)) =\n lift.{v, u} (Module.rank R M)",
" Module.rank R β₯(LinearMap.range f) + Module.rank R β₯(LinearMap.ker f) = Module.rank R M",
" lift.{v, u} (Module.rank R M) = lift.{u, v} (Mod... | [
" Nontrivial R",
" False",
" lift.{u, v} (Module.rank R β₯(LinearMap.range f)) + lift.{v, u} (Module.rank R β₯(LinearMap.ker f)) =\n lift.{v, u} (Module.rank R M)",
" Module.rank R β₯(LinearMap.range f) + Module.rank R β₯(LinearMap.ker f) = Module.rank R M",
" lift.{v, u} (Module.rank R M) = lift.{u, v} (Mod... |
import Mathlib.LinearAlgebra.Dimension.Basic
import Mathlib.SetTheory.Cardinal.ToNat
#align_import linear_algebra.finrank from "leanprover-community/mathlib"@"347636a7a80595d55bedf6e6fbd996a3c39da69a"
universe u v w
open Cardinal Submodule Module Function
variable {R : Type u} {M : Type v} {N : Type w}
variable... | Mathlib/LinearAlgebra/Dimension/Finrank.lean | 78 | 81 | theorem finrank_lt_of_rank_lt {n : β} (h : Module.rank R M < βn) : finrank R M < n := by |
rwa [β Cardinal.toNat_lt_iff_lt_of_lt_aleph0, toNat_natCast] at h
Β· exact h.trans (nat_lt_aleph0 n)
Β· exact nat_lt_aleph0 n
| [
" finrank R M = n",
" finrank R M β€ n",
" Module.rank R M < β΅β",
" βn < β΅β",
" finrank R M < n"
] | [
" finrank R M = n",
" finrank R M β€ n",
" Module.rank R M < β΅β",
" βn < β΅β"
] |
import Mathlib.Analysis.NormedSpace.IndicatorFunction
import Mathlib.MeasureTheory.Function.EssSup
import Mathlib.MeasureTheory.Function.AEEqFun
import Mathlib.MeasureTheory.Function.SpecialFunctions.Basic
#align_import measure_theory.function.lp_seminorm from "leanprover-community/mathlib"@"c4015acc0a223449d44061e27... | Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean | 96 | 98 | theorem snorm_one_eq_lintegral_nnnorm {f : Ξ± β F} : snorm f 1 ΞΌ = β«β» x, βf xββ βΞΌ := by |
simp_rw [snorm_eq_lintegral_rpow_nnnorm one_ne_zero ENNReal.coe_ne_top, ENNReal.one_toReal,
one_div_one, ENNReal.rpow_one]
| [
" snorm f p ΞΌ = snorm' f p.toReal ΞΌ",
" snorm f p ΞΌ = (β«β» (x : Ξ±), ββf xββ ^ p.toReal βΞΌ) ^ (1 / p.toReal)",
" snorm f 1 ΞΌ = β«β» (x : Ξ±), ββf xββ βΞΌ"
] | [
" snorm f p ΞΌ = snorm' f p.toReal ΞΌ",
" snorm f p ΞΌ = (β«β» (x : Ξ±), ββf xββ ^ p.toReal βΞΌ) ^ (1 / p.toReal)"
] |
import Mathlib.Algebra.Group.Commute.Units
import Mathlib.Algebra.Group.Int
import Mathlib.Algebra.GroupWithZero.Semiconj
import Mathlib.Data.Nat.GCD.Basic
import Mathlib.Order.Bounds.Basic
#align_import data.int.gcd from "leanprover-community/mathlib"@"47a1a73351de8dd6c8d3d32b569c8e434b03ca47"
namespace Nat
... | Mathlib/Data/Int/GCD.lean | 86 | 90 | theorem gcdA_zero_right {s : β} (h : s β 0) : gcdA s 0 = 1 := by |
unfold gcdA xgcd
obtain β¨s, rflβ© := Nat.exists_eq_succ_of_ne_zero h
rw [xgcdAux]
simp
| [
" (invImage\n (fun x =>\n PSigma.casesOn x fun a a_1 =>\n PSigma.casesOn a_1 fun a_2 a_3 =>\n PSigma.casesOn a_3 fun a_4 a_5 => PSigma.casesOn a_5 fun a_6 a_7 => PSigma.casesOn a_7 fun a_8 a_9 => a)\n instWellFoundedRelationOfSizeOf).1\n β¨r' % k.succ, β¨s' - βq * s, ... | [
" (invImage\n (fun x =>\n PSigma.casesOn x fun a a_1 =>\n PSigma.casesOn a_1 fun a_2 a_3 =>\n PSigma.casesOn a_3 fun a_4 a_5 => PSigma.casesOn a_5 fun a_6 a_7 => PSigma.casesOn a_7 fun a_8 a_9 => a)\n instWellFoundedRelationOfSizeOf).1\n β¨r' % k.succ, β¨s' - βq * s, ... |
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.GroupTheory.Submonoid.Center
#align_import group_theory.subgroup.basic from "leanprover-community/mathlib"@"4be589053caf347b899a494da75410deb55fb3ef"
open Function
open Int
variable {G : Type*} [Group G]
namespace Subgroup
variable (G)
@[to_additive
... | Mathlib/GroupTheory/Subgroup/Center.lean | 73 | 75 | theorem mem_center_iff {z : G} : z β center G β β g, g * z = z * g := by |
rw [β Semigroup.mem_center_iff]
exact Iff.rfl
| [
" r * ββu = ββu * r",
" 0 * ββu = ββu * 0",
" (fun u => (unitsCenterToCenterUnits Gβ) u)\n ({ toFun := fun u => β¨ββu, β―β©, map_one' := ?m.1734, map_mul' := β― }.toHomUnits xβ) =\n xβ",
" ββ((fun u => (unitsCenterToCenterUnits Gβ) u)\n ({ toFun := fun u => β¨ββu, β―β©, map_one' := ?m.1734, map_mul'... | [
" r * ββu = ββu * r",
" 0 * ββu = ββu * 0",
" (fun u => (unitsCenterToCenterUnits Gβ) u)\n ({ toFun := fun u => β¨ββu, β―β©, map_one' := ?m.1734, map_mul' := β― }.toHomUnits xβ) =\n xβ",
" ββ((fun u => (unitsCenterToCenterUnits Gβ) u)\n ({ toFun := fun u => β¨ββu, β―β©, map_one' := ?m.1734, map_mul'... |
import Mathlib.LinearAlgebra.TensorProduct.RightExactness
import Mathlib.LinearAlgebra.TensorProduct.Finiteness
universe u
variable (R : Type u) [CommRing R]
variable {M : Type u} [AddCommGroup M] [Module R M]
variable {N : Type u} [AddCommGroup N] [Module R N]
open Classical DirectSum LinearMap Function Submodul... | Mathlib/LinearAlgebra/TensorProduct/Vanishing.lean | 89 | 94 | theorem sum_tmul_eq_zero_of_vanishesTrivially (hmn : VanishesTrivially R m n) :
β i, m i ββ n i = (0 : M β[R] N) := by |
obtain β¨ΞΊ, _, a, y, hβ, hββ© := hmn
simp_rw [hβ, tmul_sum, tmul_smul]
rw [Finset.sum_comm]
simp_rw [β tmul_smul, β smul_tmul, β sum_tmul, hβ, zero_tmul, Finset.sum_const_zero]
| [
" β i : ΞΉ, m i ββ[R] n i = 0",
" β x : ΞΉ, β x_1 : ΞΊ, a x x_1 β’ m x ββ[R] y x_1 = 0",
" β y_1 : ΞΊ, β x : ΞΉ, a x y_1 β’ m x ββ[R] y y_1 = 0"
] | [] |
import Mathlib.FieldTheory.Finite.Polynomial
import Mathlib.NumberTheory.Basic
import Mathlib.RingTheory.WittVector.WittPolynomial
#align_import ring_theory.witt_vector.structure_polynomial from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
open MvPolynomial Set
open Finset (range)
o... | Mathlib/RingTheory/WittVector/StructurePolynomial.lean | 209 | 226 | theorem bindβ_rename_expand_wittPolynomial (Ξ¦ : MvPolynomial idx β€) (n : β)
(IH :
β m : β,
m < n + 1 β
map (Int.castRingHom β) (wittStructureInt p Ξ¦ m) =
wittStructureRat p (map (Int.castRingHom β) Ξ¦) m) :
bindβ (fun b => rename (fun i => (b, i)) (expand p (W_ β€ n))) Ξ¦ =
... |
apply MvPolynomial.map_injective (Int.castRingHom β) Int.cast_injective
simp only [map_bindβ, map_rename, map_expand, rename_expand, map_wittPolynomial]
have key := (wittStructureRat_prop p (map (Int.castRingHom β) Ξ¦) n).symm
apply_fun expand p at key
simp only [expand_bindβ] at key
rw [key]; clear key
a... | [
" (bindβ (wittStructureRat p Ξ¦)) (W_ β n) =\n (bindβ fun k => (bindβ fun i => (rename (Prod.mk i)) (W_ β k)) Ξ¦) ((bindβ (xInTermsOfW p β)) (W_ β n))",
" (bindβ (wittStructureRat p Ξ¦)) (W_ β n) =\n (bindβ fun i => (bindβ fun k => (bindβ fun i => (rename (Prod.mk i)) (W_ β k)) Ξ¦) (xInTermsOfW p β i)) (W_ β n)... | [
" (bindβ (wittStructureRat p Ξ¦)) (W_ β n) =\n (bindβ fun k => (bindβ fun i => (rename (Prod.mk i)) (W_ β k)) Ξ¦) ((bindβ (xInTermsOfW p β)) (W_ β n))",
" (bindβ (wittStructureRat p Ξ¦)) (W_ β n) =\n (bindβ fun i => (bindβ fun k => (bindβ fun i => (rename (Prod.mk i)) (W_ β k)) Ξ¦) (xInTermsOfW p β i)) (W_ β n)... |
import Mathlib.NumberTheory.LegendreSymbol.QuadraticReciprocity
#align_import number_theory.legendre_symbol.jacobi_symbol from "leanprover-community/mathlib"@"74a27133cf29446a0983779e37c8f829a85368f3"
section Jacobi
open Nat ZMod
-- Since we need the fact that the factors are prime, we use `List.pmap`.
def ... | Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean | 110 | 111 | theorem one_right (a : β€) : J(a | 1) = 1 := by |
simp only [jacobiSym, factors_one, List.prod_nil, List.pmap]
| [
" J(a | 0) = 1",
" J(a | 1) = 1"
] | [
" J(a | 0) = 1"
] |
import Mathlib.Analysis.Normed.Field.Basic
import Mathlib.RingTheory.Valuation.RankOne
import Mathlib.Topology.Algebra.Valuation
noncomputable section
open Filter Set Valuation
open scoped NNReal
variable {K : Type*} [hK : NormedField K] (h : IsNonarchimedean (norm : K β β))
namespace Valued
variable {L : Typ... | Mathlib/Topology/Algebra/NormedValued.lean | 74 | 75 | theorem norm_eq_zero {x : L} (hx : norm x = 0) : x = 0 := by |
simpa [norm, NNReal.coe_eq_zero, RankOne.hom_eq_zero_iff, zero_iff] using hx
| [
" 0 β€ norm x",
" norm (x + y) β€ max (norm x) (norm y)",
" v (x + y) β€ v x β¨ v (x + y) β€ v y",
" x = 0"
] | [
" 0 β€ norm x",
" norm (x + y) β€ max (norm x) (norm y)",
" v (x + y) β€ v x β¨ v (x + y) β€ v y"
] |
import Mathlib.Algebra.Order.Ring.Abs
#align_import data.int.order.units from "leanprover-community/mathlib"@"d012cd09a9b256d870751284dd6a29882b0be105"
namespace Int
theorem isUnit_iff_abs_eq {x : β€} : IsUnit x β abs x = 1 := by
rw [isUnit_iff_natAbs_eq, abs_eq_natAbs, β Int.ofNat_one, natCast_inj]
#align int.... | Mathlib/Data/Int/Order/Units.lean | 25 | 26 | theorem units_sq (u : β€Λ£) : u ^ 2 = 1 := by |
rw [Units.ext_iff, Units.val_pow_eq_pow_val, Units.val_one, isUnit_sq u.isUnit]
| [
" IsUnit x β |x| = 1",
" a ^ 2 = 1",
" u ^ 2 = 1"
] | [
" IsUnit x β |x| = 1",
" a ^ 2 = 1"
] |
import Mathlib.Data.Finset.Basic
import Mathlib.ModelTheory.Syntax
import Mathlib.Data.List.ProdSigma
#align_import model_theory.semantics from "leanprover-community/mathlib"@"d565b3df44619c1498326936be16f1a935df0728"
universe u v w u' v'
namespace FirstOrder
namespace Language
variable {L : Language.{u, v}} {... | Mathlib/ModelTheory/Semantics.lean | 138 | 143 | theorem realize_restrictVar [DecidableEq Ξ±] {t : L.Term Ξ±} {s : Set Ξ±} (h : βt.varFinset β s)
{v : Ξ± β M} : (t.restrictVar (Set.inclusion h)).realize (v β (β)) = t.realize v := by |
induction' t with _ _ _ _ ih
Β· rfl
Β· simp_rw [varFinset, Finset.coe_biUnion, Set.iUnion_subset_iff] at h
exact congr rfl (funext fun i => ih i (h i (Finset.mem_univ i)))
| [
" realize v (relabel g t) = realize (v β g) t",
" realize v (relabel g (var aβ)) = realize (v β g) (var aβ)",
" realize v (relabel g (func f ts)) = realize (v β g) (func f ts)",
" realize v (f.applyβ t) = funMap f ![realize v t]",
" (funMap f fun i => realize v (![t] i)) = funMap f ![realize v t]",
" real... | [
" realize v (relabel g t) = realize (v β g) t",
" realize v (relabel g (var aβ)) = realize (v β g) (var aβ)",
" realize v (relabel g (func f ts)) = realize (v β g) (func f ts)",
" realize v (f.applyβ t) = funMap f ![realize v t]",
" (funMap f fun i => realize v (![t] i)) = funMap f ![realize v t]",
" real... |
import Mathlib.Init.Data.Prod
import Mathlib.Data.Seq.WSeq
#align_import data.seq.parallel from "leanprover-community/mathlib"@"a7e36e48519ab281320c4d192da6a7b348ce40ad"
universe u v
namespace Computation
open Stream'
variable {Ξ± : Type u} {Ξ² : Type v}
def parallel.aux2 : List (Computation Ξ±) β Sum Ξ± (List (Com... | Mathlib/Data/Seq/Parallel.lean | 57 | 119 | theorem terminates_parallel.aux :
β {l : List (Computation Ξ±)} {S c},
c β l β Terminates c β Terminates (corec parallel.aux1 (l, S)) := by |
have lem1 :
β l S, (β a : Ξ±, parallel.aux2 l = Sum.inl a) β Terminates (corec parallel.aux1 (l, S)) := by
intro l S e
cases' e with a e
have : corec parallel.aux1 (l, S) = return a := by
apply destruct_eq_pure
simp only [parallel.aux1, rmap, corec_eq]
rw [e]
rw [this]
-- Por... | [
" β {l : List (Computation Ξ±)} {S : WSeq (Computation Ξ±)} {c : Computation Ξ±},\n c β l β c.Terminates β (corec parallel.aux1 (l, S)).Terminates",
" β (l : List (Computation Ξ±)) (S : WSeq (Computation Ξ±)),\n (β a, parallel.aux2 l = Sum.inl a) β (corec parallel.aux1 (l, S)).Terminates",
" (corec parallel.au... | [] |
import Mathlib.Algebra.Polynomial.Coeff
import Mathlib.Algebra.Polynomial.Degree.Lemmas
import Mathlib.RingTheory.PowerSeries.Basic
#align_import ring_theory.power_series.basic from "leanprover-community/mathlib"@"2d5739b61641ee4e7e53eca5688a08f66f2e6a60"
noncomputable section
open Polynomial
open Finset (antid... | Mathlib/RingTheory/PowerSeries/Trunc.lean | 108 | 120 | theorem evalβ_trunc_eq_sum_range {S : Type*} [Semiring S] (s : S) (G : R β+* S) (n) (f : Rβ¦Xβ§) :
(trunc n f).evalβ G s = β i β range n, G (coeff R i f) * s ^ i := by |
cases n with
| zero =>
rw [trunc_zero', range_zero, sum_empty, evalβ_zero]
| succ n =>
have := natDegree_trunc_lt f n
rw [evalβ_eq_sum_range' (hn := this)]
apply sum_congr rfl
intro _ h
rw [mem_range] at h
congr
rw [coeff_trunc, if_pos h]
| [
" (trunc n Ο).coeff m = if m < n then (coeff R m) Ο else 0",
" (trunc n 0).coeff m = Polynomial.coeff 0 m",
" (if m < n then 0 else 0) = 0",
" 0 = 0",
" (trunc (n + 1) 1).coeff m = Polynomial.coeff 1 m",
" (if m < n + 1 then if m = 0 then 1 else 0 else 0) = if m = 0 then 1 else 0",
" 1 = 1",
" 0 = 1",... | [
" (trunc n Ο).coeff m = if m < n then (coeff R m) Ο else 0",
" (trunc n 0).coeff m = Polynomial.coeff 0 m",
" (if m < n then 0 else 0) = 0",
" 0 = 0",
" (trunc (n + 1) 1).coeff m = Polynomial.coeff 1 m",
" (if m < n + 1 then if m = 0 then 1 else 0 else 0) = if m = 0 then 1 else 0",
" 1 = 1",
" 0 = 1",... |
import Mathlib.Algebra.Order.Sub.Defs
import Mathlib.Data.Finset.Basic
import Mathlib.Order.Interval.Finset.Defs
open Function
namespace Finset
class HasAntidiagonal (A : Type*) [AddMonoid A] where
antidiagonal : A β Finset (A Γ A)
mem_antidiagonal {n} {a} : a β antidiagonal n β a.fst + a.snd = n
exp... | Mathlib/Data/Finset/Antidiagonal.lean | 154 | 166 | theorem filter_fst_eq_antidiagonal (n m : A) [DecidablePred (Β· = m)] [Decidable (m β€ n)] :
filter (fun x : A Γ A β¦ x.fst = m) (antidiagonal n) = if m β€ n then {(m, n - m)} else β
:= by |
ext β¨a, bβ©
suffices a = m β (a + b = n β m β€ n β§ b = n - m) by
rw [mem_filter, mem_antidiagonal, apply_ite (fun n β¦ (a, b) β n), mem_singleton,
Prod.mk.inj_iff, ite_prop_iff_or]
simpa [ β and_assoc, @and_right_comm _ (a = _), and_congr_left_iff]
rintro rfl
constructor
Β· rintro rfl
exact β¨le... | [
" β (a b : HasAntidiagonal A), a = b",
" { antidiagonal := a, mem_antidiagonal := ha } = { antidiagonal := b, mem_antidiagonal := hb }",
" xy β a n β xy β b n",
" antidiagonal = antidiagonal",
" H1 = H2",
" xy.swap β antidiagonal n β xy β antidiagonal n",
" (a, b) β map (Equiv.prodComm A A).toEmbedding ... | [
" β (a b : HasAntidiagonal A), a = b",
" { antidiagonal := a, mem_antidiagonal := ha } = { antidiagonal := b, mem_antidiagonal := hb }",
" xy β a n β xy β b n",
" antidiagonal = antidiagonal",
" H1 = H2",
" xy.swap β antidiagonal n β xy β antidiagonal n",
" (a, b) β map (Equiv.prodComm A A).toEmbedding ... |
import Mathlib.Data.Set.Pointwise.Basic
import Mathlib.Data.Set.MulAntidiagonal
#align_import data.finset.mul_antidiagonal from "leanprover-community/mathlib"@"0a0ec35061ed9960bf0e7ffb0335f44447b58977"
namespace Set
open Pointwise
variable {Ξ± : Type*} {s t : Set Ξ±}
@[to_additive]
| Mathlib/Data/Finset/MulAntidiagonal.lean | 25 | 27 | theorem IsPWO.mul [OrderedCancelCommMonoid Ξ±] (hs : s.IsPWO) (ht : t.IsPWO) : IsPWO (s * t) := by |
rw [β image_mul_prod]
exact (hs.prod ht).image_of_monotone (monotone_fst.mul' monotone_snd)
| [
" (s * t).IsPWO",
" ((fun x => x.1 * x.2) '' s ΓΛ’ t).IsPWO"
] | [] |
import Mathlib.Data.Finsupp.Defs
#align_import data.finsupp.fin from "leanprover-community/mathlib"@"f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c"
noncomputable section
namespace Finsupp
variable {n : β} (i : Fin n) {M : Type*} [Zero M] (y : M) (t : Fin (n + 1) ββ M) (s : Fin n ββ M)
def tail (s : Fin (n + 1) ββ ... | Mathlib/Data/Finsupp/Fin.lean | 89 | 92 | theorem cons_ne_zero_iff : cons y s β 0 β y β 0 β¨ s β 0 := by |
refine β¨fun h => ?_, fun h => h.casesOn cons_ne_zero_of_left cons_ne_zero_of_rightβ©
refine imp_iff_not_or.1 fun h' c => h ?_
rw [h', c, Finsupp.cons_zero_zero]
| [
" (cons y s).tail k = s k",
" cons (t 0) t.tail = t",
" (cons (t 0) t.tail) a = t a",
" cons 0 0 = 0",
" (cons 0 0) a = 0 a",
" 0 (a.pred c) = 0 (a.pred c).succ",
" cons y s β 0",
" y = 0",
" s = 0",
" s a = 0 a",
" cons y s β 0 β y β 0 β¨ s β 0",
" y β 0 β¨ s β 0",
" cons y s = 0"
] | [
" (cons y s).tail k = s k",
" cons (t 0) t.tail = t",
" (cons (t 0) t.tail) a = t a",
" cons 0 0 = 0",
" (cons 0 0) a = 0 a",
" 0 (a.pred c) = 0 (a.pred c).succ",
" cons y s β 0",
" y = 0",
" s = 0",
" s a = 0 a"
] |
import Mathlib.Tactic.Ring
#align_import algebra.group_power.identities from "leanprover-community/mathlib"@"c4658a649d216f57e99621708b09dcb3dcccbd23"
variable {R : Type*} [CommRing R] {a b xβ xβ xβ xβ xβ
xβ xβ xβ yβ yβ yβ yβ yβ
yβ yβ yβ n : R}
theorem sq_add_sq_mul_sq_add_sq :
(xβ ^ 2 + xβ ^ 2) * (yβ ^ 2 +... | Mathlib/Algebra/Ring/Identities.lean | 46 | 48 | theorem pow_four_add_four_mul_pow_four' :
a ^ 4 + 4 * b ^ 4 = (a ^ 2 - 2 * a * b + 2 * b ^ 2) * (a ^ 2 + 2 * a * b + 2 * b ^ 2) := by |
ring
| [
" (xβ ^ 2 + xβ ^ 2) * (yβ ^ 2 + yβ ^ 2) = (xβ * yβ - xβ * yβ) ^ 2 + (xβ * yβ + xβ * yβ) ^ 2",
" (xβ ^ 2 + n * xβ ^ 2) * (yβ ^ 2 + n * yβ ^ 2) = (xβ * yβ - n * xβ * yβ) ^ 2 + n * (xβ * yβ + xβ * yβ) ^ 2",
" a ^ 4 + 4 * b ^ 4 = ((a - b) ^ 2 + b ^ 2) * ((a + b) ^ 2 + b ^ 2)",
" a ^ 4 + 4 * b ^ 4 = (a ^ 2 - 2 * a... | [
" (xβ ^ 2 + xβ ^ 2) * (yβ ^ 2 + yβ ^ 2) = (xβ * yβ - xβ * yβ) ^ 2 + (xβ * yβ + xβ * yβ) ^ 2",
" (xβ ^ 2 + n * xβ ^ 2) * (yβ ^ 2 + n * yβ ^ 2) = (xβ * yβ - n * xβ * yβ) ^ 2 + n * (xβ * yβ + xβ * yβ) ^ 2",
" a ^ 4 + 4 * b ^ 4 = ((a - b) ^ 2 + b ^ 2) * ((a + b) ^ 2 + b ^ 2)"
] |
import Mathlib.MeasureTheory.Group.GeometryOfNumbers
import Mathlib.MeasureTheory.Measure.Lebesgue.VolumeOfBalls
import Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic
#align_import number_theory.number_field.canonical_embedding from "leanprover-community/mathlib"@"60da01b41bbe4206f05d34fd70c8dd7498717a30"
... | Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean | 337 | 343 | theorem convexBodySumFun_continuous :
Continuous (convexBodySumFun : (E K) β β) := by |
refine continuous_finset_sum Finset.univ fun w β¦ ?_
obtain hw | hw := isReal_or_isComplex w
all_goals
Β· simp only [normAtPlace_apply_isReal, normAtPlace_apply_isComplex, hw]
fun_prop
| [
" convexBodySumFun x = β w : { w // w.IsReal }, βx.1 wβ + 2 * β w : { w // w.IsComplex }, βx.2 wβ",
" β x_1 β Finset.subtype (fun x => x.IsReal) Finset.univ, β(βx_1).mult * (normAtPlace βx_1) x +\n β x_1 β Finset.subtype (fun x => x.IsComplex) Finset.univ, β(βx_1).mult * (normAtPlace βx_1) x =\n β x_1 β F... | [
" convexBodySumFun x = β w : { w // w.IsReal }, βx.1 wβ + 2 * β w : { w // w.IsComplex }, βx.2 wβ",
" β x_1 β Finset.subtype (fun x => x.IsReal) Finset.univ, β(βx_1).mult * (normAtPlace βx_1) x +\n β x_1 β Finset.subtype (fun x => x.IsComplex) Finset.univ, β(βx_1).mult * (normAtPlace βx_1) x =\n β x_1 β F... |
import Mathlib.Data.Set.Lattice
#align_import data.set.intervals.disjoint from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
universe u v w
variable {ΞΉ : Sort u} {Ξ± : Type v} {Ξ² : Type w}
open Set
open OrderDual (toDual)
namespace Set
section Preorder
variable [Preorder Ξ±] {a b c... | Mathlib/Order/Interval/Set/Disjoint.lean | 127 | 128 | theorem iUnion_Ioc_left [NoMinOrder Ξ±] (b : Ξ±) : β a, Ioc a b = Iic b := by |
simp only [β Ioi_inter_Iic, β iUnion_inter, iUnion_Ioi, univ_inter]
| [
" Disjoint (Ici a) (Iic b) β Β¬a β€ b",
" β b, Icc a b = Ici a",
" β b, Ioc a b = Ioi a",
" β a, Icc a b = Iic b",
" β a, Ico a b = Iio b",
" β b, Ico a b = Ici a",
" β b, Ioo a b = Ioi a",
" β a, Ioc a b = Iic b"
] | [
" Disjoint (Ici a) (Iic b) β Β¬a β€ b",
" β b, Icc a b = Ici a",
" β b, Ioc a b = Ioi a",
" β a, Icc a b = Iic b",
" β a, Ico a b = Iio b",
" β b, Ico a b = Ici a",
" β b, Ioo a b = Ioi a"
] |
import Mathlib.MeasureTheory.Decomposition.SignedHahn
import Mathlib.MeasureTheory.Measure.MutuallySingular
#align_import measure_theory.decomposition.jordan from "leanprover-community/mathlib"@"70a4f2197832bceab57d7f41379b2592d1110570"
noncomputable section
open scoped Classical MeasureTheory ENNReal NNReal
va... | Mathlib/MeasureTheory/Decomposition/Jordan.lean | 242 | 248 | theorem toJordanDecomposition_spec (s : SignedMeasure Ξ±) :
β (i : Set Ξ±) (hiβ : MeasurableSet i) (hiβ : 0 β€[i] s) (hiβ : s β€[iαΆ] 0),
s.toJordanDecomposition.posPart = s.toMeasureOfZeroLE i hiβ hiβ β§
s.toJordanDecomposition.negPart = s.toMeasureOfLEZero iαΆ hiβ.compl hiβ := by |
set i := s.exists_compl_positive_negative.choose
obtain β¨hiβ, hiβ, hiββ© := s.exists_compl_positive_negative.choose_spec
exact β¨i, hiβ, hiβ, hiβ, rfl, rflβ©
| [
" s.toMeasureOfZeroLE i β― β― ββ s.toMeasureOfLEZero iαΆ β― β―",
" (s.toMeasureOfZeroLE i β― β―) iαΆ = 0",
" ββ¨βs (β―.choose β© β―.chooseαΆ), β―β© = 0",
" (s.toMeasureOfLEZero iαΆ β― β―) iαΆαΆ = 0",
" ββ¨-βs (β―.chooseαΆ β© β―.chooseαΆαΆ), β―β© = 0",
" β i,\n β (hiβ : MeasurableSet i) (hiβ : VectorMeasure.restrict 0 i β€ VectorMea... | [
" s.toMeasureOfZeroLE i β― β― ββ s.toMeasureOfLEZero iαΆ β― β―",
" (s.toMeasureOfZeroLE i β― β―) iαΆ = 0",
" ββ¨βs (β―.choose β© β―.chooseαΆ), β―β© = 0",
" (s.toMeasureOfLEZero iαΆ β― β―) iαΆαΆ = 0",
" ββ¨-βs (β―.chooseαΆ β© β―.chooseαΆαΆ), β―β© = 0"
] |
import Mathlib.MeasureTheory.Integral.Lebesgue
open Set hiding restrict restrict_apply
open Filter ENNReal NNReal MeasureTheory.Measure
namespace MeasureTheory
variable {Ξ± : Type*} {m0 : MeasurableSpace Ξ±} {ΞΌ : Measure Ξ±}
noncomputable
def Measure.withDensity {m : MeasurableSpace Ξ±} (ΞΌ : Measure Ξ±) (f : Ξ± β ββ₯... | Mathlib/MeasureTheory/Measure/WithDensity.lean | 130 | 135 | theorem withDensity_smul' (r : ββ₯0β) (f : Ξ± β ββ₯0β) (hr : r β β) :
ΞΌ.withDensity (r β’ f) = r β’ ΞΌ.withDensity f := by |
refine Measure.ext fun s hs => ?_
rw [withDensity_apply _ hs, Measure.coe_smul, Pi.smul_apply, withDensity_apply _ hs,
smul_eq_mul, β lintegral_const_mul' r f hr]
simp only [Pi.smul_apply, smul_eq_mul]
| [
" (fun s x => β«β» (a : Ξ±) in s, f a βΞΌ) β
β― = 0",
" β«β» (a : Ξ±) in s, f a βΞΌ β€ (ΞΌ.withDensity f) s",
" (ΞΌ.withDensity f) s = β«β» (a : Ξ±) in s, f a βΞΌ",
" (ΞΌ.withDensity f) s β€ β«β» (a : Ξ±) in s, f a βΞΌ",
" β«β» (a : Ξ±) in t, f a βΞΌ = β«β» (a : Ξ±) in s, f a βΞΌ",
" ΞΌ.restrict t = ΞΌ.restrict s",
" withDensity 0 f =... | [
" (fun s x => β«β» (a : Ξ±) in s, f a βΞΌ) β
β― = 0",
" β«β» (a : Ξ±) in s, f a βΞΌ β€ (ΞΌ.withDensity f) s",
" (ΞΌ.withDensity f) s = β«β» (a : Ξ±) in s, f a βΞΌ",
" (ΞΌ.withDensity f) s β€ β«β» (a : Ξ±) in s, f a βΞΌ",
" β«β» (a : Ξ±) in t, f a βΞΌ = β«β» (a : Ξ±) in s, f a βΞΌ",
" ΞΌ.restrict t = ΞΌ.restrict s",
" withDensity 0 f =... |
import Mathlib.Combinatorics.SimpleGraph.Clique
import Mathlib.Data.ENat.Lattice
import Mathlib.Data.Nat.Lattice
import Mathlib.Data.Setoid.Partition
import Mathlib.Order.Antichain
#align_import combinatorics.simple_graph.coloring from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
open ... | Mathlib/Combinatorics/SimpleGraph/Coloring.lean | 151 | 155 | theorem isEmpty_of_colorable_zero (h : G.Colorable 0) : IsEmpty V := by |
constructor
intro v
obtain β¨i, hiβ© := h.some v
exact Nat.not_lt_zero _ hi
| [
" card βC.colorClasses β€ card Ξ±",
" card β(Setoid.ker βC).classes β€ card Ξ±",
" Fintype β(Setoid.ker βC).classes",
" Fintype (G.Coloring Ξ±)",
" Fintype (G.Adj βr β€.Adj)",
" IsEmpty V",
" V β False",
" False"
] | [
" card βC.colorClasses β€ card Ξ±",
" card β(Setoid.ker βC).classes β€ card Ξ±",
" Fintype β(Setoid.ker βC).classes",
" Fintype (G.Coloring Ξ±)",
" Fintype (G.Adj βr β€.Adj)"
] |
import Mathlib.Data.Matrix.Basis
import Mathlib.LinearAlgebra.Basis
import Mathlib.LinearAlgebra.Pi
#align_import linear_algebra.std_basis from "leanprover-community/mathlib"@"13bce9a6b6c44f6b4c91ac1c1d2a816e2533d395"
open Function Set Submodule
namespace LinearMap
variable (R : Type*) {ΞΉ : Type*} [Semiring R] ... | Mathlib/LinearAlgebra/StdBasis.lean | 73 | 77 | theorem stdBasis_eq_pi_diag (i : ΞΉ) : stdBasis R Ο i = pi (diag i) := by |
ext x j
-- Porting note: made types explicit
convert (update_apply (R := R) (Ο := Ο) (ΞΉ := ΞΉ) 0 x i j _).symm
rfl
| [
" (stdBasis R (fun _x => R) i) 1 i' = if i = i' then 1 else 0",
" (if i' = i then 1 else 0) = if i = i' then 1 else 0",
" (i' = i) = (i = i')",
" stdBasis R Ο i = pi (diag i)",
" (stdBasis R Ο i) x j = (pi (diag i)) x j",
" x = id x"
] | [
" (stdBasis R (fun _x => R) i) 1 i' = if i = i' then 1 else 0",
" (if i' = i then 1 else 0) = if i = i' then 1 else 0",
" (i' = i) = (i = i')"
] |
import Mathlib.LinearAlgebra.AffineSpace.AffineEquiv
#align_import linear_algebra.affine_space.midpoint from "leanprover-community/mathlib"@"2196ab363eb097c008d4497125e0dde23fb36db2"
open AffineMap AffineEquiv
section
variable (R : Type*) {V V' P P' : Type*} [Ring R] [Invertible (2 : R)] [AddCommGroup V]
[Modu... | Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean | 140 | 143 | theorem vsub_midpoint (pβ pβ p : P) :
p -α΅₯ midpoint R pβ pβ = (β
2 : R) β’ (p -α΅₯ pβ) + (β
2 : R) β’ (p -α΅₯ pβ) := by |
rw [β neg_vsub_eq_vsub_rev, midpoint_vsub, neg_add, β smul_neg, β smul_neg, neg_vsub_eq_vsub_rev,
neg_vsub_eq_vsub_rev]
| [
" (pointReflection R (midpoint R x y)) x = y",
" (pointReflection (midpoint R x y)) x = y",
" midpoint R x y = midpoint R y x",
" (pointReflection R (midpoint R x y)) y = x",
" (pointReflection (midpoint R x y)) y = x",
" midpoint R pβ pβ -α΅₯ pβ = β
2 β’ (pβ -α΅₯ pβ)",
" pβ -α΅₯ midpoint R pβ pβ = β
2 β’ (pβ -α΅₯ ... | [
" (pointReflection R (midpoint R x y)) x = y",
" (pointReflection (midpoint R x y)) x = y",
" midpoint R x y = midpoint R y x",
" (pointReflection R (midpoint R x y)) y = x",
" (pointReflection (midpoint R x y)) y = x",
" midpoint R pβ pβ -α΅₯ pβ = β
2 β’ (pβ -α΅₯ pβ)",
" pβ -α΅₯ midpoint R pβ pβ = β
2 β’ (pβ -α΅₯ ... |
import Mathlib.Algebra.Group.Subsemigroup.Basic
#align_import group_theory.subsemigroup.membership from "leanprover-community/mathlib"@"6cb77a8eaff0ddd100e87b1591c6d3ad319514ff"
assert_not_exists MonoidWithZero
variable {ΞΉ : Sort*} {M A B : Type*}
section NonAssoc
variable [Mul M]
open Set
namespace Subsemigr... | Mathlib/Algebra/Group/Subsemigroup/Membership.lean | 102 | 104 | theorem mem_iSup_of_mem {S : ΞΉ β Subsemigroup M} (i : ΞΉ) : β {x : M}, x β S i β x β iSup S := by |
have : S i β€ iSup S := le_iSup _ _
tauto
| [
" x β β¨ i, S i β β i, x β S i",
" x β β¨ i, S i β β i, x β S i",
" x β closure (β i, β(S i)) β β i, x β S i",
" β (x y : M), (β i, x β S i) β (β i, y β S i) β β i, x * y β S i",
" β i, x * y β S i",
" x β β(β¨ i, S i) β x β β i, β(S i)",
" x β sSup S β β s β S, x β s",
" x β β(sSup S) β x β β s β S, βs"... | [
" x β β¨ i, S i β β i, x β S i",
" x β β¨ i, S i β β i, x β S i",
" x β closure (β i, β(S i)) β β i, x β S i",
" β (x y : M), (β i, x β S i) β (β i, y β S i) β β i, x * y β S i",
" β i, x * y β S i",
" x β β(β¨ i, S i) β x β β i, β(S i)",
" x β sSup S β β s β S, x β s",
" x β β(sSup S) β x β β s β S, βs"... |
import Mathlib.CategoryTheory.Limits.Shapes.CommSq
import Mathlib.CategoryTheory.Limits.Shapes.Diagonal
import Mathlib.CategoryTheory.MorphismProperty.Composition
universe v u
namespace CategoryTheory
open Limits
namespace MorphismProperty
variable {C : Type u} [Category.{v} C]
def StableUnderBaseChange (P : ... | Mathlib/CategoryTheory/MorphismProperty/Limits.lean | 58 | 62 | theorem StableUnderBaseChange.respectsIso {P : MorphismProperty C} (hP : StableUnderBaseChange P) :
RespectsIso P := by |
apply RespectsIso.of_respects_arrow_iso
intro f g e
exact hP (IsPullback.of_horiz_isIso (CommSq.mk e.inv.w))
| [
" P g'",
" P pullback.fst",
" P.RespectsIso",
" β (f g : Arrow C), (f β
g) β P f.hom β P g.hom",
" P f.hom β P g.hom"
] | [
" P g'",
" P pullback.fst"
] |
import Mathlib.RingTheory.OrzechProperty
import Mathlib.RingTheory.Ideal.Quotient
import Mathlib.RingTheory.PrincipalIdealDomain
#align_import linear_algebra.invariant_basis_number from "leanprover-community/mathlib"@"5fd3186f1ec30a75d5f65732e3ce5e623382556f"
noncomputable section
open Function
universe u v w
... | Mathlib/LinearAlgebra/InvariantBasisNumber.lean | 130 | 139 | theorem strongRankCondition_iff_succ :
StrongRankCondition R β
β (n : β) (f : (Fin (n + 1) β R) ββ[R] Fin n β R), Β¬Function.Injective f := by |
refine β¨fun h n => fun f hf => ?_, fun h => β¨@fun n m f hf => ?_β©β©
Β· letI : StrongRankCondition R := h
exact Nat.not_succ_le_self n (le_of_fin_injective R f hf)
Β· by_contra H
exact
h m (f.comp (Function.ExtendByZero.linearMap R (Fin.castLE (not_le.1 H))))
(hf.comp (Function.extend_injective... | [
" StrongRankCondition R β β (n : β) (f : (Fin (n + 1) β R) ββ[R] Fin n β R), Β¬Injective βf",
" False",
" n β€ m"
] | [] |
import Mathlib.Algebra.Order.Group.Nat
import Mathlib.Data.List.Rotate
import Mathlib.GroupTheory.Perm.Support
#align_import group_theory.perm.list from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
namespace List
variable {Ξ± Ξ² : Type*}
section FormPerm
variable [DecidableEq Ξ±] (l :... | Mathlib/GroupTheory/Perm/List.lean | 162 | 164 | theorem formPerm_apply_nthLe_length (x : Ξ±) (xs : List Ξ±) :
formPerm (x :: xs) ((x :: xs).nthLe xs.length (by simp)) = x := by |
apply formPerm_apply_get_length
| [
" (zipWith swap [] xβΒΉ).prod xβ β xβ β xβ β [] β¨ xβ β xβΒΉ",
" (zipWith swap xβΒΉ []).prod xβ β xβ β xβ β xβΒΉ β¨ xβ β []",
" (swap (?m.1920 a l b l' x hx h) (?m.1921 a l b l' x hx h)) (?m.1919 a l b l' x hx h) β ?m.1919 a l b l' x hx h",
" x = a β x β a :: l",
" x β x :: l",
" x = b β x β b :: l'",
" x β x... | [
" (zipWith swap [] xβΒΉ).prod xβ β xβ β xβ β [] β¨ xβ β xβΒΉ",
" (zipWith swap xβΒΉ []).prod xβ β xβ β xβ β xβΒΉ β¨ xβ β []",
" (swap (?m.1920 a l b l' x hx h) (?m.1921 a l b l' x hx h)) (?m.1919 a l b l' x hx h) β ?m.1919 a l b l' x hx h",
" x = a β x β a :: l",
" x β x :: l",
" x = b β x β b :: l'",
" x β x... |
import Mathlib.Data.Set.Lattice
#align_import data.set.intervals.disjoint from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
universe u v w
variable {ΞΉ : Sort u} {Ξ± : Type v} {Ξ² : Type w}
open Set
open OrderDual (toDual)
namespace Set
section Preorder
variable [Preorder Ξ±] {a b c... | Mathlib/Order/Interval/Set/Disjoint.lean | 97 | 98 | theorem iUnion_Icc_left (b : Ξ±) : β a, Icc a b = Iic b := by |
simp only [β Ici_inter_Iic, β iUnion_inter, iUnion_Ici, univ_inter]
| [
" Disjoint (Ici a) (Iic b) β Β¬a β€ b",
" β b, Icc a b = Ici a",
" β b, Ioc a b = Ioi a",
" β a, Icc a b = Iic b"
] | [
" Disjoint (Ici a) (Iic b) β Β¬a β€ b",
" β b, Icc a b = Ici a",
" β b, Ioc a b = Ioi a"
] |
import Mathlib.Algebra.MvPolynomial.Counit
import Mathlib.Algebra.MvPolynomial.Invertible
import Mathlib.RingTheory.WittVector.Defs
#align_import ring_theory.witt_vector.basic from "leanprover-community/mathlib"@"9556784a5b84697562e9c6acb40500d4a82e675a"
noncomputable section
open MvPolynomial Function
variable... | Mathlib/RingTheory/WittVector/Basic.lean | 117 | 117 | theorem neg : mapFun f (-x) = -mapFun f x := by | map_fun_tac
| [
" Injective (mapFun f)",
" aββ = aββ",
" aββ.coeff p = aββ.coeff p",
" mapFun f (mk p fun n => Classical.choose β―) = x",
" (mapFun f (mk p fun n => Classical.choose β―)).coeff n = x.coeff n",
" mapFun (βf) 0 = 0",
" mapFun (βf) 1 = 1",
" mapFun (βf) (x + y) = mapFun (βf) x + mapFun (βf) y",
" mapFun ... | [
" Injective (mapFun f)",
" aββ = aββ",
" aββ.coeff p = aββ.coeff p",
" mapFun f (mk p fun n => Classical.choose β―) = x",
" (mapFun f (mk p fun n => Classical.choose β―)).coeff n = x.coeff n",
" mapFun (βf) 0 = 0",
" mapFun (βf) 1 = 1",
" mapFun (βf) (x + y) = mapFun (βf) x + mapFun (βf) y",
" mapFun ... |
import Mathlib.RingTheory.Localization.AtPrime
import Mathlib.RingTheory.Localization.Basic
import Mathlib.RingTheory.Localization.FractionRing
#align_import ring_theory.localization.localization_localization from "leanprover-community/mathlib"@"831c494092374cfe9f50591ed0ac81a25efc5b86"
open Function
namespace ... | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | 125 | 133 | theorem localization_localization_isLocalization_of_has_all_units [IsLocalization N T]
(H : β x : S, IsUnit x β x β N) : IsLocalization (N.comap (algebraMap R S)) T := by |
convert localization_localization_isLocalization M N T using 1
dsimp [localizationLocalizationSubmodule]
congr
symm
rw [sup_eq_left]
rintro _ β¨x, hx, rflβ©
exact H _ (IsLocalization.map_units _ β¨x, hxβ©)
| [
" x β localizationLocalizationSubmodule M N β β y z, (algebraMap R S) x = βy * (algebraMap R S) βz",
" (β y β N, β z β Submonoid.map (algebraMap R S) M, y * z = (algebraMap R S) x) β\n β y z, (algebraMap R S) x = βy * (algebraMap R S) βz",
" (β y β N, β z β Submonoid.map (algebraMap R S) M, y * z = (algebraM... | [
" x β localizationLocalizationSubmodule M N β β y z, (algebraMap R S) x = βy * (algebraMap R S) βz",
" (β y β N, β z β Submonoid.map (algebraMap R S) M, y * z = (algebraMap R S) x) β\n β y z, (algebraMap R S) x = βy * (algebraMap R S) βz",
" (β y β N, β z β Submonoid.map (algebraMap R S) M, y * z = (algebraM... |
import Mathlib.CategoryTheory.NatIso
import Mathlib.CategoryTheory.FullSubcategory
#align_import category_theory.essential_image from "leanprover-community/mathlib"@"550b58538991c8977703fdeb7c9d51a5aa27df11"
universe vβ vβ vβ uβ uβ uβ
noncomputable section
namespace CategoryTheory
variable {C : Type uβ} {D : T... | Mathlib/CategoryTheory/EssentialImage.lean | 169 | 172 | theorem essSurj_of_surj (h : Function.Surjective F.obj) : EssSurj F where
mem_essImage Y := by |
obtain β¨X, rflβ© := h Y
apply obj_mem_essImage
| [
" Y β F.essImage",
" F.obj X β F.essImage"
] | [] |
import Mathlib.Data.Set.Pointwise.SMul
import Mathlib.Topology.MetricSpace.Isometry
import Mathlib.Topology.MetricSpace.Lipschitz
#align_import topology.metric_space.isometric_smul from "leanprover-community/mathlib"@"bc91ed7093bf098d253401e69df601fc33dde156"
open Set
open ENNReal Pointwise
universe u v w
vari... | Mathlib/Topology/MetricSpace/IsometricSMul.lean | 149 | 151 | theorem edist_div_left [PseudoEMetricSpace G] [IsometricSMul G G] [IsometricSMul Gα΅α΅α΅ G]
(a b c : G) : edist (a / b) (a / c) = edist b c := by |
rw [div_eq_mul_inv, div_eq_mul_inv, edist_mul_left, edist_inv_inv]
| [
" edist ((fun x => c β’ x) x) ((fun x => c β’ x) y) = edist x y",
" edist (a / c) (b / c) = edist a b",
" edist aβ»ΒΉ bβ»ΒΉ = edist a b",
" edist xβ»ΒΉ y = edist x yβ»ΒΉ",
" edist (a / b) (a / c) = edist b c"
] | [
" edist ((fun x => c β’ x) x) ((fun x => c β’ x) y) = edist x y",
" edist (a / c) (b / c) = edist a b",
" edist aβ»ΒΉ bβ»ΒΉ = edist a b",
" edist xβ»ΒΉ y = edist x yβ»ΒΉ"
] |
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 | 120 | 124 | theorem norm_eq' (hp : 0 < p) {x : β} : β(x : AddCircle p)β = p * |pβ»ΒΉ * x - round (pβ»ΒΉ * x)| := by |
conv_rhs =>
congr
rw [β abs_eq_self.mpr hp.le]
rw [β abs_mul, mul_sub, mul_inv_cancel_leftβ hp.ne.symm, norm_eq, mul_comm p]
| [
" ββ(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.Order.Interval.Finset.Nat
import Mathlib.Data.PNat.Defs
#align_import data.pnat.interval from "leanprover-community/mathlib"@"1d29de43a5ba4662dd33b5cfeecfc2a27a5a8a29"
open Finset Function PNat
namespace PNat
variable (a b : β+)
instance instLocallyFiniteOrder : LocallyFiniteOrder β+ := Subtype.... | Mathlib/Data/PNat/Interval.lean | 103 | 104 | theorem card_uIcc : (uIcc a b).card = (b - a : β€).natAbs + 1 := by |
rw [β Nat.card_uIcc, β map_subtype_embedding_uIcc, card_map]
| [
" (Icc a b).card = βb + 1 - βa",
" (Icc a b).card = (Icc βa βb).card",
" (Icc a b).card = (map (Embedding.subtype fun n => 0 < n) (Icc a b)).card",
" (Ico a b).card = βb - βa",
" (Ico a b).card = (Ico βa βb).card",
" (Ico a b).card = (map (Embedding.subtype fun n => 0 < n) (Ico a b)).card",
" (Ioc a b).... | [
" (Icc a b).card = βb + 1 - βa",
" (Icc a b).card = (Icc βa βb).card",
" (Icc a b).card = (map (Embedding.subtype fun n => 0 < n) (Icc a b)).card",
" (Ico a b).card = βb - βa",
" (Ico a b).card = (Ico βa βb).card",
" (Ico a b).card = (map (Embedding.subtype fun n => 0 < n) (Ico a b)).card",
" (Ioc a b).... |
import Mathlib.Data.Vector.Basic
import Mathlib.Data.Vector.Snoc
set_option autoImplicit true
namespace Vector
section Fold
section Binary
variable (xs : Vector Ξ± n) (ys : Vector Ξ² n)
@[simp]
theorem mapAccumrβ_mapAccumr_left (fβ : Ξ³ β Ξ² β Οβ β Οβ Γ ΞΆ) (fβ : Ξ± β Οβ β Οβ Γ Ξ³) :
(mapAccumrβ fβ (mapAccumr fβ... | Mathlib/Data/Vector/MapLemmas.lean | 103 | 105 | theorem map_mapβ (fβ : Ξ³ β ΞΆ) (fβ : Ξ± β Ξ² β Ξ³) :
map fβ (mapβ fβ xs ys) = mapβ (fun x y => fβ <| fβ x y) xs ys := by |
induction xs, ys using Vector.revInductionOnβ <;> simp_all
| [
" mapAccumrβ fβ (mapAccumr fβ xs sβ).2 ys sβ =\n let m :=\n mapAccumrβ\n (fun x y s =>\n let rβ := fβ x s.2;\n let rβ := fβ rβ.2 y s.1;\n ((rβ.1, rβ.1), rβ.2))\n xs ys (sβ, sβ);\n (m.1.1, m.2)",
" mapAccumrβ fβ (mapAccumr fβ nil sβ).2 nil sβ =\n let m :=\n ... | [
" mapAccumrβ fβ (mapAccumr fβ xs sβ).2 ys sβ =\n let m :=\n mapAccumrβ\n (fun x y s =>\n let rβ := fβ x s.2;\n let rβ := fβ rβ.2 y s.1;\n ((rβ.1, rβ.1), rβ.2))\n xs ys (sβ, sβ);\n (m.1.1, m.2)",
" mapAccumrβ fβ (mapAccumr fβ nil sβ).2 nil sβ =\n let m :=\n ... |
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.Algebra.Polynomial.RingDivision
#align_import field_theory.ratfunc from "leanprover-community/mathlib"@"bf9bbbcf0c1c1ead18280b0d010e417b10abb1b6"
noncomputable section
open scoped Classical
open scoped nonZeroDivisors Polynomial
universe u v
va... | Mathlib/FieldTheory/RatFunc/Defs.lean | 168 | 171 | theorem mk_def_of_mem (p : K[X]) {q} (hq : q β K[X]β°) :
RatFunc.mk p q = ofFractionRing (IsLocalization.mk' (FractionRing K[X]) p β¨q, hqβ©) := by |
-- Porting note: there was an `[anonymous]` in the simp set
simp only [β mk_coe_def]
| [
" { toFractionRing := x } = { toFractionRing := y }",
" { toFractionRing := x } = { toFractionRing := { toFractionRing := x }.toFractionRing }",
" P",
" β {a c : K[X]} {b d : β₯K[X]β°},\n (Localization.r K[X]β°) (a, b) (c, d) β (fun p q => f p βq) a b = (fun p q => f p βq) c d",
" (fun p q => f p βq) p q = ... | [
" { toFractionRing := x } = { toFractionRing := y }",
" { toFractionRing := x } = { toFractionRing := { toFractionRing := x }.toFractionRing }",
" P",
" β {a c : K[X]} {b d : β₯K[X]β°},\n (Localization.r K[X]β°) (a, b) (c, d) β (fun p q => f p βq) a b = (fun p q => f p βq) c d",
" (fun p q => f p βq) p q = ... |
import Mathlib.Data.List.Basic
import Mathlib.Data.Sigma.Basic
#align_import data.list.prod_sigma from "leanprover-community/mathlib"@"dd71334db81d0bd444af1ee339a29298bef40734"
variable {Ξ± Ξ² : Type*}
namespace List
@[simp]
theorem nil_product (l : List Ξ²) : (@nil Ξ±) ΓΛ’ l = [] :=
rfl
#align list.nil_product... | Mathlib/Data/List/ProdSigma.lean | 82 | 85 | theorem mem_sigma {lβ : List Ξ±} {lβ : β a, List (Ο a)} {a : Ξ±} {b : Ο a} :
Sigma.mk a b β lβ.sigma lβ β a β lβ β§ b β lβ a := by |
simp [List.sigma, mem_bind, mem_map, exists_prop, exists_and_left, and_left_comm,
exists_eq_left, heq_iff_eq, exists_eq_right]
| [
" (headβ :: l) ΓΛ’ [] = []",
" (a, b) β lβ ΓΛ’ lβ β a β lβ β§ b β lβ",
" (lβ ΓΛ’ lβ).length = lβ.length * lβ.length",
" ([] ΓΛ’ lβ).length = [].length * lβ.length",
" ((x :: lβ) ΓΛ’ lβ).length = (x :: lβ).length * lβ.length",
" ((headβ :: l).sigma fun a => []) = []",
" β¨a, bβ© β lβ.sigma lβ β a β lβ β§ b β lβ a... | [
" (headβ :: l) ΓΛ’ [] = []",
" (a, b) β lβ ΓΛ’ lβ β a β lβ β§ b β lβ",
" (lβ ΓΛ’ lβ).length = lβ.length * lβ.length",
" ([] ΓΛ’ lβ).length = [].length * lβ.length",
" ((x :: lβ) ΓΛ’ lβ).length = (x :: lβ).length * lβ.length",
" ((headβ :: l).sigma fun a => []) = []"
] |
import Mathlib.Data.Finset.Option
import Mathlib.Data.PFun
import Mathlib.Data.Part
#align_import data.finset.pimage from "leanprover-community/mathlib"@"f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c"
variable {Ξ± Ξ² : Type*}
namespace Part
def toFinset (o : Part Ξ±) [Decidable o.Dom] : Finset Ξ± :=
o.toOption.toFins... | Mathlib/Data/Finset/PImage.lean | 34 | 35 | theorem mem_toFinset {o : Part Ξ±} [Decidable o.Dom] {x : Ξ±} : x β o.toFinset β x β o := by |
simp [toFinset]
| [
" x β o.toFinset β x β o"
] | [] |
import Mathlib.Analysis.NormedSpace.HahnBanach.Extension
import Mathlib.Analysis.NormedSpace.RCLike
import Mathlib.Analysis.LocallyConvex.Polar
#align_import analysis.normed_space.dual from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open scoped Classical
open ... | Mathlib/Analysis/NormedSpace/Dual.lean | 101 | 103 | theorem dualPairing_separatingLeft : (dualPairing π E).SeparatingLeft := by |
rw [LinearMap.separatingLeft_iff_ker_eq_bot, LinearMap.ker_eq_bot]
exact ContinuousLinearMap.coe_injective
| [
" βinclusionInDoubleDual π Eβ β€ 1",
" βContinuousLinearMap.id π (Dual π E)β β€ 1",
" β(inclusionInDoubleDual π E) xβ β€ βxβ",
" (dualPairing π E).SeparatingLeft",
" Function.Injective β(dualPairing π E)"
] | [
" βinclusionInDoubleDual π Eβ β€ 1",
" βContinuousLinearMap.id π (Dual π E)β β€ 1",
" β(inclusionInDoubleDual π E) xβ β€ βxβ"
] |
import Mathlib.Algebra.BigOperators.Group.Finset
#align_import data.nat.gcd.big_operators from "leanprover-community/mathlib"@"008205aa645b3f194c1da47025c5f110c8406eab"
namespace Nat
variable {ΞΉ : Type*}
theorem coprime_list_prod_left_iff {l : List β} {k : β} :
Coprime l.prod k β β n β l, Coprime n k := by
... | Mathlib/Data/Nat/GCD/BigOperators.lean | 36 | 38 | theorem coprime_prod_left_iff {t : Finset ΞΉ} {s : ΞΉ β β} {x : β} :
Coprime (β i β t, s i) x β β i β t, Coprime (s i) x := by |
simpa using coprime_multiset_prod_left_iff (m := t.val.map s)
| [
" l.prod.Coprime k β β n β l, n.Coprime k",
" [].prod.Coprime k β β n β [], n.Coprime k",
" (headβ :: tailβ).prod.Coprime k β β n β headβ :: tailβ, n.Coprime k",
" k.Coprime l.prod β β n β l, k.Coprime n",
" m.prod.Coprime k β β n β m, n.Coprime k",
" (Multiset.prod β¦aββ§).Coprime k β β n β β¦aββ§, n.Coprime... | [
" l.prod.Coprime k β β n β l, n.Coprime k",
" [].prod.Coprime k β β n β [], n.Coprime k",
" (headβ :: tailβ).prod.Coprime k β β n β headβ :: tailβ, n.Coprime k",
" k.Coprime l.prod β β n β l, k.Coprime n",
" m.prod.Coprime k β β n β m, n.Coprime k",
" (Multiset.prod β¦aββ§).Coprime k β β n β β¦aββ§, n.Coprime... |
import Mathlib.Algebra.CharP.Invertible
import Mathlib.Algebra.Order.Interval.Set.Group
import Mathlib.Analysis.Convex.Segment
import Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional
import Mathlib.Tactic.FieldSimp
#align_import analysis.convex.between from "leanprover-community/mathlib"@"571e13cacbed7bf042fd3058c... | Mathlib/Analysis/Convex/Between.lean | 127 | 129 | theorem mem_const_vsub_affineSegment {x y z : P} (p : P) :
p -α΅₯ z β affineSegment R (p -α΅₯ x) (p -α΅₯ y) β z β affineSegment R x y := by |
rw [β affineSegment_const_vsub_image, (vsub_right_injective p).mem_set_image]
| [
" affineSegment R x y = segment R x y",
" affineSegment R x y = affineSegment R y x",
" z β affineSegment R x y β z β affineSegment R y x",
" z β affineSegment R x y β z β affineSegment R y x",
" z β affineSegment R y x",
" 1 - t β Set.Icc 0 1",
" (lineMap y x) (1 - t) = z",
" z β affineSegment R y x ... | [
" affineSegment R x y = segment R x y",
" affineSegment R x y = affineSegment R y x",
" z β affineSegment R x y β z β affineSegment R y x",
" z β affineSegment R x y β z β affineSegment R y x",
" z β affineSegment R y x",
" 1 - t β Set.Icc 0 1",
" (lineMap y x) (1 - t) = z",
" z β affineSegment R y x ... |
import Mathlib.Data.Finset.Lattice
#align_import data.finset.pairwise from "leanprover-community/mathlib"@"c4c2ed622f43768eff32608d4a0f8a6cec1c047d"
open Finset
variable {Ξ± ΞΉ ΞΉ' : Type*}
instance [DecidableEq Ξ±] {r : Ξ± β Ξ± β Prop} [DecidableRel r] {s : Finset Ξ±} :
Decidable ((s : Set Ξ±).Pairwise r) :=
dec... | Mathlib/Data/Finset/Pairwise.lean | 62 | 71 | theorem PairwiseDisjoint.biUnion_finset {s : Set ΞΉ'} {g : ΞΉ' β Finset ΞΉ} {f : ΞΉ β Ξ±}
(hs : s.PairwiseDisjoint fun i' : ΞΉ' => (g i').sup f)
(hg : β i β s, (g i : Set ΞΉ).PairwiseDisjoint f) : (β i β s, β(g i)).PairwiseDisjoint f := by |
rintro a ha b hb hab
simp_rw [Set.mem_iUnion] at ha hb
obtain β¨c, hc, haβ© := ha
obtain β¨d, hd, hbβ© := hb
obtain hcd | hcd := eq_or_ne (g c) (g d)
Β· exact hg d hd (by rwa [hcd] at ha) hb hab
Β· exact (hs hc hd (ne_of_apply_ne _ hcd)).mono (Finset.le_sup ha) (Finset.le_sup hb)
| [
" (Set.range singleton).PairwiseDisjoint id",
" (Disjoint on id) {a} {b}",
" (β i β s, β(g i)).PairwiseDisjoint f",
" (Disjoint on f) a b",
" a β β(g d)"
] | [
" (Set.range singleton).PairwiseDisjoint id",
" (Disjoint on id) {a} {b}"
] |
import Mathlib.Algebra.EuclideanDomain.Instances
import Mathlib.RingTheory.Ideal.Colon
import Mathlib.RingTheory.UniqueFactorizationDomain
#align_import ring_theory.principal_ideal_domain from "leanprover-community/mathlib"@"6010cf523816335f7bae7f8584cb2edaace73940"
universe u v
variable {R : Type u} {M : Type v... | Mathlib/RingTheory/PrincipalIdealDomain.lean | 104 | 106 | theorem generator_mem (S : Submodule R M) [S.IsPrincipal] : generator S β S := by |
conv_rhs => rw [β span_singleton_generator S]
exact subset_span (mem_singleton _)
| [
" β₯ = span R {0}",
" IsPrincipal S",
" IsPrincipal β₯",
" IsPrincipal β€",
" generator S β S",
"R : Type u\nM : Type v\ninstβΒ³ : AddCommGroup M\ninstβΒ² : Ring R\ninstβΒΉ : Module R M\nS : Submodule R M\ninstβ : S.IsPrincipal\n| S",
" generator S β span R {generator S}"
] | [
" β₯ = span R {0}",
" IsPrincipal S",
" IsPrincipal β₯",
" IsPrincipal β€"
] |
import Mathlib.Analysis.Convex.Topology
import Mathlib.Analysis.NormedSpace.Pointwise
import Mathlib.Analysis.Seminorm
import Mathlib.Analysis.LocallyConvex.Bounded
import Mathlib.Analysis.RCLike.Basic
#align_import analysis.convex.gauge from "leanprover-community/mathlib"@"373b03b5b9d0486534edbe94747f23cb3712f93d"
... | Mathlib/Analysis/Convex/Gauge.lean | 142 | 145 | theorem gauge_le_of_mem (ha : 0 β€ a) (hx : x β a β’ s) : gauge s x β€ a := by |
obtain rfl | ha' := ha.eq_or_lt
Β· rw [mem_singleton_iff.1 (zero_smul_set_subset _ hx), gauge_zero]
Β· exact csInf_le gauge_set_bddBelow β¨ha', hxβ©
| [
" gauge s x = sInf {r | r β Ioi 0 β§ rβ»ΒΉ β’ x β s}",
" 0 < r β§ x β r β’ s β r β Ioi 0 β§ rβ»ΒΉ β’ x β s",
" β b, 0 < b β§ b < a β§ x β b β’ s",
" gauge s 0 = 0",
" sInf {r | r β Ioi 0 β§ rβ»ΒΉ β’ 0 β s} = 0",
" gauge 0 = 0",
" gauge 0 x = 0 x",
" sInf {r | r β Ioi 0 β§ rβ»ΒΉ β’ x β 0} = 0 x",
" sInf {r | r β Ioi 0 β§ ... | [
" gauge s x = sInf {r | r β Ioi 0 β§ rβ»ΒΉ β’ x β s}",
" 0 < r β§ x β r β’ s β r β Ioi 0 β§ rβ»ΒΉ β’ x β s",
" β b, 0 < b β§ b < a β§ x β b β’ s",
" gauge s 0 = 0",
" sInf {r | r β Ioi 0 β§ rβ»ΒΉ β’ 0 β s} = 0",
" gauge 0 = 0",
" gauge 0 x = 0 x",
" sInf {r | r β Ioi 0 β§ rβ»ΒΉ β’ x β 0} = 0 x",
" sInf {r | r β Ioi 0 β§ ... |
import Mathlib.Algebra.Order.Monoid.Unbundled.MinMax
import Mathlib.Algebra.Order.Monoid.WithTop
import Mathlib.Data.Finset.Image
import Mathlib.Data.Multiset.Fold
#align_import data.finset.fold from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
-- TODO:
-- assert_not_exists OrderedComm... | Mathlib/Data/Finset/Fold.lean | 79 | 80 | theorem fold_congr {g : Ξ± β Ξ²} (H : β x β s, f x = g x) : s.fold op b f = s.fold op b g := by |
rw [fold, fold, map_congr rfl H]
| [
" fold op b f (cons a s h) = op (f a) (fold op b f s)",
" Multiset.fold op b (Multiset.map f (cons a s h).val) = op (f a) (Multiset.fold op b (Multiset.map f s.val))",
" fold op b f (insert a s) = op (f a) (fold op b f s)",
" Multiset.fold op b (Multiset.map f (insert a s).val) = op (f a) (Multiset.fold op b ... | [
" fold op b f (cons a s h) = op (f a) (fold op b f s)",
" Multiset.fold op b (Multiset.map f (cons a s h).val) = op (f a) (Multiset.fold op b (Multiset.map f s.val))",
" fold op b f (insert a s) = op (f a) (fold op b f s)",
" Multiset.fold op b (Multiset.map f (insert a s).val) = op (f a) (Multiset.fold op b ... |
import Mathlib.Probability.Notation
import Mathlib.Probability.Density
import Mathlib.Probability.ConditionalProbability
import Mathlib.Probability.ProbabilityMassFunction.Constructions
open scoped Classical MeasureTheory NNReal ENNReal
-- TODO: We can't `open ProbabilityTheory` without opening the `ProbabilityThe... | Mathlib/Probability/Distributions/Uniform.lean | 80 | 84 | theorem measure_preimage {X : Ξ© β E} {s : Set E} (hns : ΞΌ s β 0) (hnt : ΞΌ s β β)
(hu : IsUniform X s β ΞΌ) {A : Set E} (hA : MeasurableSet A) :
β (X β»ΒΉ' A) = ΞΌ (s β© A) / ΞΌ s := by |
rwa [β map_apply_of_aemeasurable (hu.aemeasurable hns hnt) hA, hu, ProbabilityTheory.cond_apply',
ENNReal.div_eq_inv_mul]
| [
" AEMeasurable X β",
" False",
" 0 = 1",
" 0 Set.univ = 1",
" Measure.map X β βͺ ΞΌ",
" ProbabilityTheory.cond ΞΌ s βͺ ΞΌ",
" β (X β»ΒΉ' A) = ΞΌ (s β© A) / ΞΌ s"
] | [
" AEMeasurable X β",
" False",
" 0 = 1",
" 0 Set.univ = 1",
" Measure.map X β βͺ ΞΌ",
" ProbabilityTheory.cond ΞΌ s βͺ ΞΌ"
] |
import Mathlib.Topology.Compactness.SigmaCompact
import Mathlib.Topology.Connected.TotallyDisconnected
import Mathlib.Topology.Inseparable
#align_import topology.separation from "leanprover-community/mathlib"@"d91e7f7a7f1c7e9f0e18fdb6bde4f652004c735d"
open Function Set Filter Topology TopologicalSpace
open scoped... | Mathlib/Topology/Separation.lean | 201 | 203 | theorem t0Space_iff_not_inseparable (X : Type u) [TopologicalSpace X] :
T0Space X β Pairwise fun x y : X => Β¬Inseparable x y := by |
simp only [t0Space_iff_inseparable, Ne, not_imp_not, Pairwise]
| [
" SeparatedNhds s t β Disjoint (πΛ’ s) (πΛ’ t)",
" T0Space X β Pairwise fun x y => Β¬Inseparable x y"
] | [
" SeparatedNhds s t β Disjoint (πΛ’ s) (πΛ’ t)"
] |
import Mathlib.Data.Set.Image
import Mathlib.Order.Interval.Set.Basic
#align_import data.set.intervals.with_bot_top from "leanprover-community/mathlib"@"d012cd09a9b256d870751284dd6a29882b0be105"
open Set
variable {Ξ± : Type*}
namespace WithTop
@[simp]
theorem preimage_coe_top : (some : Ξ± β WithTop Ξ±) β»ΒΉ' {β€} =... | Mathlib/Order/Interval/Set/WithBotTop.lean | 63 | 63 | theorem preimage_coe_Ico : (some : Ξ± β WithTop Ξ±) β»ΒΉ' Ico a b = Ico a b := by | simp [β Ici_inter_Iio]
| [
" range some = Iio β€",
" x β range some β x β Iio β€",
" some β»ΒΉ' Icc βa βb = Icc a b",
" some β»ΒΉ' Ico βa βb = Ico a b"
] | [
" range some = Iio β€",
" x β range some β x β Iio β€",
" some β»ΒΉ' Icc βa βb = Icc a b"
] |
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 | 83 | 85 | theorem isAcyclic_iff_forall_edge_isBridge :
G.IsAcyclic β β β¦eβ¦, e β (G.edgeSet) β G.IsBridge e := by |
simp [isAcyclic_iff_forall_adj_isBridge, Sym2.forall]
| [
" 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.SetTheory.Ordinal.Arithmetic
namespace Cardinal
universe u
variable {Ξ± : Type u}
variable (g : Ordinal β Ξ±)
open Cardinal Ordinal SuccOrder Function Set
| Mathlib/SetTheory/Ordinal/FixedPointApproximants.lean | 49 | 56 | theorem not_injective_limitation_set : Β¬ InjOn g (Iio (ord <| succ #Ξ±)) := by |
intro h_inj
have h := lift_mk_le_lift_mk_of_injective <| injOn_iff_injective.1 h_inj
have mk_initialSeg_subtype :
#(Iio (ord <| succ #Ξ±)) = lift.{u + 1} (succ #Ξ±) := by
simpa only [coe_setOf, card_typein, card_ord] using mk_initialSeg (ord <| succ #Ξ±)
rw [mk_initialSeg_subtype, lift_lift, lift_le] at... | [
" Β¬InjOn g (Iio (succ #Ξ±).ord)",
" False",
" #β(Iio (succ #Ξ±).ord) = lift.{u + 1, u} (succ #Ξ±)"
] | [] |
import Mathlib.Algebra.Group.Units.Equiv
import Mathlib.CategoryTheory.Endomorphism
#align_import category_theory.conj from "leanprover-community/mathlib"@"32253a1a1071173b33dc7d6a218cf722c6feb514"
universe v u
namespace CategoryTheory
namespace Iso
variable {C : Type u} [Category.{v} C]
def homCongr {X Y Xβ... | Mathlib/CategoryTheory/Conj.lean | 55 | 56 | theorem homCongr_comp {X Y Z Xβ Yβ Zβ : C} (Ξ± : X β
Xβ) (Ξ² : Y β
Yβ) (Ξ³ : Z β
Zβ) (f : X βΆ Y)
(g : Y βΆ Z) : Ξ±.homCongr Ξ³ (f β« g) = Ξ±.homCongr Ξ² f β« Ξ².homCongr Ξ³ g := by | simp
| [
" Ξ±.hom β« (Ξ±.inv β« f β« Ξ².hom) β« Ξ².inv = f",
" Ξ±.inv β« (Ξ±.hom β« f β« Ξ².inv) β« Ξ².hom = f",
" (Ξ±.homCongr Ξ²) f = Ξ±.inv β« f β« Ξ².hom",
" (Ξ±.homCongr Ξ³) (f β« g) = (Ξ±.homCongr Ξ²) f β« (Ξ².homCongr Ξ³) g"
] | [
" Ξ±.hom β« (Ξ±.inv β« f β« Ξ².hom) β« Ξ².inv = f",
" Ξ±.inv β« (Ξ±.hom β« f β« Ξ².inv) β« Ξ².hom = f",
" (Ξ±.homCongr Ξ²) f = Ξ±.inv β« f β« Ξ².hom"
] |
import Mathlib.CategoryTheory.Abelian.Opposite
import Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero
import Mathlib.CategoryTheory.Limits.Preserves.Shapes.Kernels
import Mathlib.CategoryTheory.Preadditive.LeftExact
import Mathlib.CategoryTheory.Adjunction.Limits
import Mathlib.Algebra.Homology.Exact
import Mathli... | Mathlib/CategoryTheory/Abelian/Exact.lean | 66 | 81 | theorem exact_iff : Exact f g β f β« g = 0 β§ kernel.ΞΉ g β« cokernel.Ο f = 0 := by |
constructor
Β· exact fun h β¦ β¨h.1, kernel_comp_cokernel f g hβ©
Β· refine fun h β¦ β¨h.1, ?_β©
suffices hl : IsLimit
(KernelFork.ofΞΉ (imageSubobject f).arrow (imageSubobject_arrow_comp_eq_zero h.1)) by
have : imageToKernel f g h.1 = (hl.conePointUniqueUpToIso (limit.isLimit _)).hom β«
(kerne... | [
" Exact f g β imageSubobject f = kernelSubobject g",
" Exact f g β imageSubobject f = kernelSubobject g",
" imageSubobject f = kernelSubobject g",
" (asIso (imageToKernel f g β―)).hom β« (kernelSubobject g).arrow = (imageSubobject f).arrow",
" imageSubobject f = kernelSubobject g β Exact f g",
" Exact f g β... | [
" Exact f g β imageSubobject f = kernelSubobject g",
" Exact f g β imageSubobject f = kernelSubobject g",
" imageSubobject f = kernelSubobject g",
" (asIso (imageToKernel f g β―)).hom β« (kernelSubobject g).arrow = (imageSubobject f).arrow",
" imageSubobject f = kernelSubobject g β Exact f g"
] |
import Mathlib.Algebra.Polynomial.Eval
import Mathlib.LinearAlgebra.Dimension.Constructions
#align_import algebra.linear_recurrence from "leanprover-community/mathlib"@"039a089d2a4b93c761b234f3e5f5aeb752bac60f"
noncomputable section
open Finset
open Polynomial
structure LinearRecurrence (Ξ± : Type*) [CommSemir... | Mathlib/Algebra/LinearRecurrence.lean | 100 | 115 | theorem eq_mk_of_is_sol_of_eq_init {u : β β Ξ±} {init : Fin E.order β Ξ±} (h : E.IsSolution u)
(heq : β n : Fin E.order, u n = init n) : β n, u n = E.mkSol init n := by |
intro n
rw [mkSol]
split_ifs with h'
Β· exact mod_cast heq β¨n, h'β©
simp only
rw [β tsub_add_cancel_of_le (le_of_not_lt h'), h (n - E.order)]
congr with k
have : n - E.order + k < n := by
rw [add_comm, β add_tsub_assoc_of_le (not_lt.mp h'), tsub_lt_iff_left]
Β· exact add_lt_add_right k.is_lt n
... | [
" n - E.order + βk < n",
" βk + n < E.order + n",
" E.order β€ βk + n",
" E.order = 0 + E.order",
" E.IsSolution (E.mkSol init)",
" E.mkSol init (n + E.order) = β i : Fin E.order, E.coeffs i * E.mkSol init (n + βi)",
" (if h : n + E.order < E.order then init β¨n + E.order, hβ©\n else\n β k : Fin E.... | [
" n - E.order + βk < n",
" βk + n < E.order + n",
" E.order β€ βk + n",
" E.order = 0 + E.order",
" E.IsSolution (E.mkSol init)",
" E.mkSol init (n + E.order) = β i : Fin E.order, E.coeffs i * E.mkSol init (n + βi)",
" (if h : n + E.order < E.order then init β¨n + E.order, hβ©\n else\n β k : Fin E.... |
import Mathlib.Data.Nat.Bits
import Mathlib.Order.Lattice
#align_import data.nat.size from "leanprover-community/mathlib"@"18a5306c091183ac90884daa9373fa3b178e8607"
namespace Nat
section
set_option linter.deprecated false
theorem shiftLeft_eq_mul_pow (m) : β n, m <<< n = m * 2 ^ n := shiftLeft_eq _
#align nat.... | Mathlib/Data/Nat/Size.lean | 38 | 39 | theorem shiftLeft'_ne_zero_left (b) {m} (h : m β 0) (n) : shiftLeft' b m n β 0 := by |
induction n <;> simp [bit_ne_zero, shiftLeft', *]
| [
" shiftLeft' true m 0 + 1 = (m + 1) * 2 ^ 0",
" shiftLeft' true m (k + 1) + 1 = (m + 1) * 2 ^ (k + 1)",
" bit1 (shiftLeft' true m k) + 1 = (m + 1) * (2 ^ k * 2)",
" 2 * shiftLeft' true m k + 1 + 1 = (m + 1) * (2 ^ k * 2)",
" 2 * (shiftLeft' true m k + 1) = (m + 1) * (2 ^ k * 2)",
" shiftLeft' b m n β 0",
... | [
" shiftLeft' true m 0 + 1 = (m + 1) * 2 ^ 0",
" shiftLeft' true m (k + 1) + 1 = (m + 1) * 2 ^ (k + 1)",
" bit1 (shiftLeft' true m k) + 1 = (m + 1) * (2 ^ k * 2)",
" 2 * shiftLeft' true m k + 1 + 1 = (m + 1) * (2 ^ k * 2)",
" 2 * (shiftLeft' true m k + 1) = (m + 1) * (2 ^ k * 2)"
] |
import Mathlib.Data.List.Basic
namespace List
variable {Ξ± Ξ² : Type*}
#align list.length_enum_from List.enumFrom_length
#align list.length_enum List.enum_length
@[simp]
theorem get?_enumFrom :
β n (l : List Ξ±) m, get? (enumFrom n l) m = (get? l m).map fun a => (n + m, a)
| n, [], m => rfl
| n, a :: l, 0 =... | Mathlib/Data/List/Enum.lean | 82 | 85 | theorem fst_lt_add_of_mem_enumFrom {x : β Γ Ξ±} {n : β} {l : List Ξ±} (h : x β enumFrom n l) :
x.1 < n + length l := by |
rcases mem_iff_get.1 h with β¨i, rflβ©
simpa using i.is_lt
| [
" Option.map (fun a => (n + 1 + m, a)) (l.get? m) = Option.map (fun a => (n + (m + 1), a)) ((a :: l).get? (m + 1))",
" Option.map (fun a => (n + m + 1, a)) (l.get? m) = Option.map (fun a => (n + (m + 1), a)) ((a :: l).get? (m + 1))",
" l.enum.get? n = Option.map (fun a => (n, a)) (l.get? n)",
" (enumFrom n l)... | [
" Option.map (fun a => (n + 1 + m, a)) (l.get? m) = Option.map (fun a => (n + (m + 1), a)) ((a :: l).get? (m + 1))",
" Option.map (fun a => (n + m + 1, a)) (l.get? m) = Option.map (fun a => (n + (m + 1), a)) ((a :: l).get? (m + 1))",
" l.enum.get? n = Option.map (fun a => (n, a)) (l.get? n)",
" (enumFrom n l)... |
import Mathlib.Algebra.Lie.OfAssociative
import Mathlib.LinearAlgebra.Matrix.Reindex
import Mathlib.LinearAlgebra.Matrix.ToLinearEquiv
#align_import algebra.lie.matrix from "leanprover-community/mathlib"@"55e2dfde0cff928ce5c70926a3f2c7dee3e2dd99"
universe u v w wβ wβ
section Matrices
open scoped Matrix
variabl... | Mathlib/Algebra/Lie/Matrix.lean | 69 | 72 | theorem Matrix.lieConj_apply (P A : Matrix n n R) (h : Invertible P) :
P.lieConj h A = P * A * Pβ»ΒΉ := by |
simp [LinearEquiv.conj_apply, Matrix.lieConj, LinearMap.toMatrix'_comp,
LinearMap.toMatrix'_toLin']
| [
" (β__srcβ).toFun β
T, Sβ = β
(β__srcβ).toFun T, (β__srcβ).toFun Sβ",
" f (T ββ S - S ββ T) = f T * f S - f S * f T",
" (P.lieConj h) A = P * A * Pβ»ΒΉ"
] | [
" (β__srcβ).toFun β
T, Sβ = β
(β__srcβ).toFun T, (β__srcβ).toFun Sβ",
" f (T ββ S - S ββ T) = f T * f S - f S * f T"
] |
import Mathlib.Data.Nat.Bitwise
import Mathlib.SetTheory.Game.Birthday
import Mathlib.SetTheory.Game.Impartial
#align_import set_theory.game.nim from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
noncomputable section
universe u
namespace SetTheory
open scoped PGame
namespace PGame... | Mathlib/SetTheory/Game/Nim.lean | 119 | 119 | theorem moveRight_nim {o : Ordinal} (i) : (nim o).moveRight (toRightMovesNim i) = nim i := by | simp
| [
" let_fun this := β―;\n nim o =\n mk (Quotient.out o).Ξ± (Quotient.out o).Ξ± (fun oβ => nim (typein (fun x x_1 => x < x_1) oβ)) fun oβ =>\n nim (typein (fun x x_1 => x < x_1) oβ)",
" let_fun this := β―;\n (mk (Quotient.out o).Ξ± (Quotient.out o).Ξ±\n (fun oβ =>\n let_fun x := β―;\n nim (type... | [
" let_fun this := β―;\n nim o =\n mk (Quotient.out o).Ξ± (Quotient.out o).Ξ± (fun oβ => nim (typein (fun x x_1 => x < x_1) oβ)) fun oβ =>\n nim (typein (fun x x_1 => x < x_1) oβ)",
" let_fun this := β―;\n (mk (Quotient.out o).Ξ± (Quotient.out o).Ξ±\n (fun oβ =>\n let_fun x := β―;\n nim (type... |
import Mathlib.LinearAlgebra.LinearPMap
import Mathlib.Topology.Algebra.Module.Basic
#align_import topology.algebra.module.linear_pmap from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Topology
variable {R E F : Type*}
variable [CommRing R] [AddCommGroup E] [AddCommGroup F]
vari... | Mathlib/Topology/Algebra/Module/LinearPMap.lean | 112 | 115 | theorem IsClosable.graph_closure_eq_closure_graph {f : E ββ.[R] F} (hf : f.IsClosable) :
f.graph.topologicalClosure = f.closure.graph := by |
rw [closure_def hf]
exact hf.choose_spec
| [
" g.IsClosable",
" g.graph.topologicalClosure β€ f'.graph",
" g.graph.topologicalClosure β€ f.graph.topologicalClosure",
" g.graph.topologicalClosure = g.graph.topologicalClosure.toLinearPMap.graph",
" β x β g.graph.topologicalClosure, x.1 = 0 β x.2 = 0",
" β! f', f.graph.topologicalClosure = f'.graph",
"... | [
" g.IsClosable",
" g.graph.topologicalClosure β€ f'.graph",
" g.graph.topologicalClosure β€ f.graph.topologicalClosure",
" g.graph.topologicalClosure = g.graph.topologicalClosure.toLinearPMap.graph",
" β x β g.graph.topologicalClosure, x.1 = 0 β x.2 = 0",
" β! f', f.graph.topologicalClosure = f'.graph",
"... |
import Mathlib.Logic.Relation
import Mathlib.Data.List.Forall2
import Mathlib.Data.List.Lex
import Mathlib.Data.List.Infix
#align_import data.list.chain from "leanprover-community/mathlib"@"dd71334db81d0bd444af1ee339a29298bef40734"
-- Make sure we haven't imported `Data.Nat.Order.Basic`
assert_not_exists OrderedSu... | Mathlib/Data/List/Chain.lean | 58 | 59 | theorem chain_singleton {a b : Ξ±} : Chain R a [b] β R a b := by |
simp only [chain_cons, Chain.nil, and_true_iff]
| [
" Chain (fun x y => x β a :: l β§ y β l β§ R x y) a l",
" Chain (fun x y => x β [aβ] β§ y β [] β§ R x y) aβ []",
" Chain (fun x y => x β a :: b :: l β§ y β b :: l β§ R x y) a (b :: l)",
" a β a :: b :: l β§ b β b :: l β§ R a b",
" Chain (fun x y => x β a :: b :: l β§ y β b :: l β§ R x y) b l",
" Chain R a [b] β R a... | [
" Chain (fun x y => x β a :: l β§ y β l β§ R x y) a l",
" Chain (fun x y => x β [aβ] β§ y β [] β§ R x y) aβ []",
" Chain (fun x y => x β a :: b :: l β§ y β b :: l β§ R x y) a (b :: l)",
" a β a :: b :: l β§ b β b :: l β§ R a b",
" Chain (fun x y => x β a :: b :: l β§ y β b :: l β§ R x y) b l"
] |
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.Module.Defs
import Mathlib.Tactic.Abel
namespace Finset
variable {R M : Type*} [Ring R] [AddCommGroup M] [Module R M] (f : β β R) (g : β β M) {m n : β}
-- The partial sum of `g`, starting from zero
local notation "G " n:80 => β i β range n, g i
... | Mathlib/Algebra/BigOperators/Module.lean | 21 | 57 | theorem sum_Ico_by_parts (hmn : m < n) :
β i β Ico m n, f i β’ g i =
f (n - 1) β’ G n - f m β’ G m - β i β Ico m (n - 1), (f (i + 1) - f i) β’ G (i + 1) := by |
have hβ : (β i β Ico (m + 1) n, f i β’ G i) = β i β Ico m (n - 1), f (i + 1) β’ G (i + 1) := by
rw [β Nat.sub_add_cancel (Nat.one_le_of_lt hmn), β sum_Ico_add']
simp only [ge_iff_le, tsub_le_iff_right, add_le_iff_nonpos_left, nonpos_iff_eq_zero,
tsub_eq_zero_iff_le, add_tsub_cancel_right]
have hβ :
... | [
" β i β Ico m n, f i β’ g i =\n f (n - 1) β’ β i β range n, g i - f m β’ β i β range m, g i -\n β i β Ico m (n - 1), (f (i + 1) - f i) β’ β i β range (i + 1), g i",
" β i β Ico (m + 1) n, f i β’ β i β range i, g i = β i β Ico m (n - 1), f (i + 1) β’ β i β range (i + 1), g i",
" β x β Ico m (n - 1), f (x + 1) ... | [] |
import Mathlib.Algebra.Ring.Regular
import Mathlib.Data.Int.GCD
import Mathlib.Data.Int.Order.Lemmas
import Mathlib.Tactic.NormNum.Basic
#align_import data.nat.modeq from "leanprover-community/mathlib"@"47a1a73351de8dd6c8d3d32b569c8e434b03ca47"
assert_not_exists Function.support
namespace Nat
def ModEq (n a b :... | Mathlib/Data/Nat/ModEq.lean | 78 | 78 | theorem modEq_zero_iff_dvd : a β‘ 0 [MOD n] β n β£ a := by | rw [ModEq, zero_mod, dvd_iff_mod_eq_zero]
| [
" a β‘ 0 [MOD n] β n β£ a"
] | [] |
import Mathlib.Analysis.Calculus.Deriv.Add
import Mathlib.Analysis.Calculus.Deriv.Linear
import Mathlib.LinearAlgebra.AffineSpace.AffineMap
variable {π : Type*} [NontriviallyNormedField π]
{E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
(f : π βα΅[π] E) {a b : E} {L : Filter π} {s : Set π} {x : π}
n... | Mathlib/Analysis/Calculus/Deriv/AffineMap.lean | 36 | 38 | theorem hasDerivAtFilter : HasDerivAtFilter f (f.linear 1) x L := by |
rw [f.decomp]
exact f.linear.hasDerivAtFilter.add_const (f 0)
| [
" HasStrictDerivAt (βf) (f.linear 1) x",
" HasStrictDerivAt (βf.linear + fun x => f 0) (f.linear 1) x",
" HasDerivAtFilter (βf) (f.linear 1) x L",
" HasDerivAtFilter (βf.linear + fun x => f 0) (f.linear 1) x L"
] | [
" HasStrictDerivAt (βf) (f.linear 1) x",
" HasStrictDerivAt (βf.linear + fun x => f 0) (f.linear 1) x"
] |
import Mathlib.LinearAlgebra.AffineSpace.Basis
import Mathlib.LinearAlgebra.Matrix.NonsingularInverse
#align_import linear_algebra.affine_space.matrix from "leanprover-community/mathlib"@"2de9c37fa71dde2f1c6feff19876dd6a7b1519f0"
open Affine Matrix
open Set
universe uβ uβ uβ uβ
variable {ΞΉ : Type uβ} {k : Type... | Mathlib/LinearAlgebra/AffineSpace/Matrix.lean | 81 | 105 | theorem affineSpan_eq_top_of_toMatrix_left_inv [Finite ΞΉ] [Fintype ΞΉ'] [DecidableEq ΞΉ]
[Nontrivial k] (p : ΞΉ' β P) {A : Matrix ΞΉ ΞΉ' k} (hA : A * b.toMatrix p = 1) :
affineSpan k (range p) = β€ := by |
cases nonempty_fintype ΞΉ
suffices β i, b i β affineSpan k (range p) by
rw [eq_top_iff, β b.tot, affineSpan_le]
rintro q β¨i, rflβ©
exact this i
intro i
have hAi : β j, A i j = 1 := by
calc
β j, A i j = β j, A i j * β l, b.toMatrix p j l := by simp
_ = β j, β l, A i j * b.toMatrix p j ... | [
" b.toMatrix βb = 1",
" b.toMatrix (βb) i j = 1 i j",
" β j : ΞΉ, b.toMatrix q i j = 1",
" AffineIndependent k p",
" β (w1 w2 : ΞΉ' β k),\n β i : ΞΉ', w1 i = 1 β\n β i : ΞΉ', w2 i = 1 β\n (Finset.affineCombination k Finset.univ p) w1 = (Finset.affineCombination k Finset.univ p) w2 β w1 = w2",
"... | [
" b.toMatrix βb = 1",
" b.toMatrix (βb) i j = 1 i j",
" β j : ΞΉ, b.toMatrix q i j = 1",
" AffineIndependent k p",
" β (w1 w2 : ΞΉ' β k),\n β i : ΞΉ', w1 i = 1 β\n β i : ΞΉ', w2 i = 1 β\n (Finset.affineCombination k Finset.univ p) w1 = (Finset.affineCombination k Finset.univ p) w2 β w1 = w2",
"... |
import Mathlib.Algebra.MvPolynomial.Basic
import Mathlib.Data.Finset.PiAntidiagonal
import Mathlib.LinearAlgebra.StdBasis
import Mathlib.Tactic.Linarith
#align_import ring_theory.power_series.basic from "leanprover-community/mathlib"@"2d5739b61641ee4e7e53eca5688a08f66f2e6a60"
noncomputable section
open Finset (... | Mathlib/RingTheory/MvPowerSeries/Basic.lean | 144 | 147 | theorem coeff_monomial_same (n : Ο ββ β) (a : R) : coeff R n (monomial R n a) = a := by |
classical
rw [monomial_def]
exact LinearMap.stdBasis_same R (fun _ β¦ R) n a
| [
" monomial R n = LinearMap.stdBasis R (fun x => R) n",
" LinearMap.stdBasis R (fun x => R) n = LinearMap.stdBasis R (fun x => R) n",
" (coeff R m) ((monomial R n) a) = if m = n then a else 0",
" (LinearMap.stdBasis R (fun x => R) n) a m = if m = n then a else 0",
" (coeff R n) ((monomial R n) a) = a",
" (... | [
" monomial R n = LinearMap.stdBasis R (fun x => R) n",
" LinearMap.stdBasis R (fun x => R) n = LinearMap.stdBasis R (fun x => R) n",
" (coeff R m) ((monomial R n) a) = if m = n then a else 0",
" (LinearMap.stdBasis R (fun x => R) n) a m = if m = n then a else 0"
] |
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 | 376 | 379 | theorem smul_mat_cons (x : Ξ±) (v : n' β Ξ±) (A : Fin m β n' β Ξ±) :
x β’ vecCons v A = vecCons (x β’ v) (x β’ A) := by |
ext i
refine Fin.cases ?_ ?_ i <;> simp
| [
" 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",
" x β’ vecCons v A = vecCons (x β’ v) (x β’ A)",
" (x β’ vecCons v A) i xβ = vecCons (x β’ v) (x β’ A) i xβ",
" (x β’ vecCo... | [
" 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"
] |
import Mathlib.Probability.ProbabilityMassFunction.Monad
#align_import probability.probability_mass_function.constructions from "leanprover-community/mathlib"@"4ac69b290818724c159de091daa3acd31da0ee6d"
universe u
namespace PMF
noncomputable section
variable {Ξ± Ξ² Ξ³ : Type*}
open scoped Classical
open NNReal ENN... | Mathlib/Probability/ProbabilityMassFunction/Constructions.lean | 259 | 259 | theorem mem_support_normalize_iff (a : Ξ±) : a β (normalize f hf0 hf).support β f a β 0 := by | simp
| [
" (map f p) b = β' (a : Ξ±), if b = f a then p a else 0",
" b β (map f p).support β b β f '' p.support",
" b β (map f p).support β β a β p.support, f a = b",
" map g (map f p) = map (g β f) p",
" map (Function.const Ξ± b) p = pure b",
" a β (normalize f hf0 hf).support β a β Function.support f",
" a β (no... | [
" (map f p) b = β' (a : Ξ±), if b = f a then p a else 0",
" b β (map f p).support β b β f '' p.support",
" b β (map f p).support β β a β p.support, f a = b",
" map g (map f p) = map (g β f) p",
" map (Function.const Ξ± b) p = pure b",
" a β (normalize f hf0 hf).support β a β Function.support f"
] |
import Mathlib.Topology.Category.Profinite.Basic
universe u
namespace Profinite
variable {ΞΉ : Type u} {X : ΞΉ β Type} [β i, TopologicalSpace (X i)] (C : Set ((i : ΞΉ) β X i))
(J K : ΞΉ β Prop)
namespace IndexFunctor
open ContinuousMap
def obj : Set ((i : {i : ΞΉ // J i}) β X i) := ContinuousMap.precomp (Subty... | Mathlib/Topology/Category/Profinite/Product.lean | 68 | 75 | theorem eq_of_forall_Ο_app_eq (a b : C)
(h : β (J : Finset ΞΉ), Ο_app C (Β· β J) a = Ο_app C (Β· β J) b) : a = b := by |
ext i
specialize h ({i} : Finset ΞΉ)
rw [Subtype.ext_iff] at h
simp only [Ο_app, ContinuousMap.precomp, ContinuousMap.coe_mk,
Set.MapsTo.val_restrict_apply] at h
exact congr_fun h β¨i, Finset.mem_singleton.mpr rflβ©
| [
" (precomp (Set.inclusion h)) xβ β obj C J",
" (precomp (Set.inclusion h)) ((precomp Subtype.val) y) β obj C J",
" Function.Surjective β(Ο_app C J)",
" β a, (Ο_app C J) a = x",
" a = b",
" βa i = βb i"
] | [
" (precomp (Set.inclusion h)) xβ β obj C J",
" (precomp (Set.inclusion h)) ((precomp Subtype.val) y) β obj C J",
" Function.Surjective β(Ο_app C J)",
" β a, (Ο_app C J) a = x"
] |
import Mathlib.Algebra.Group.Subgroup.Actions
import Mathlib.Algebra.Order.Module.Algebra
import Mathlib.LinearAlgebra.LinearIndependent
import Mathlib.Algebra.Ring.Subring.Units
#align_import linear_algebra.ray from "leanprover-community/mathlib"@"0f6670b8af2dff699de1c0b4b49039b31bc13c46"
noncomputable section
... | Mathlib/LinearAlgebra/Ray.lean | 74 | 76 | theorem refl (x : M) : SameRay R x x := by |
nontriviality R
exact Or.inr (Or.inr <| β¨1, 1, zero_lt_one, zero_lt_one, rflβ©)
| [
" SameRay R x y",
" SameRay R 0 y",
" SameRay R x x"
] | [
" SameRay R x y",
" SameRay R 0 y"
] |
import Mathlib.MeasureTheory.Integral.ExpDecay
import Mathlib.Analysis.MellinTransform
#align_import analysis.special_functions.gamma.basic from "leanprover-community/mathlib"@"cca40788df1b8755d5baf17ab2f27dacc2e17acb"
noncomputable section
set_option linter.uppercaseLean3 false
open Filter intervalIntegral Set... | Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean | 71 | 82 | theorem GammaIntegral_convergent {s : β} (h : 0 < s) :
IntegrableOn (fun x : β => exp (-x) * x ^ (s - 1)) (Ioi 0) := by |
rw [β Ioc_union_Ioi_eq_Ioi (@zero_le_one β _ _ _ _), integrableOn_union]
constructor
Β· rw [β integrableOn_Icc_iff_integrableOn_Ioc]
refine IntegrableOn.continuousOn_mul continuousOn_id.neg.rexp ?_ isCompact_Icc
refine (intervalIntegrable_iff_integrableOn_Icc_of_le zero_le_one).mp ?_
exact intervalInt... | [
" (fun x => rexp (-x) * x ^ s) =o[atTop] fun x => rexp (-(1 / 2) * x)",
" rexp (-x) * x ^ s = 0",
" False",
" Tendsto (fun x => rexp (-x) * x ^ s / rexp (-(1 / 2) * x)) atTop (π 0)",
" (fun x => rexp (-x) * x ^ s / rexp (-(1 / 2) * x)) = (fun x => rexp (1 / 2 * x) / x ^ s)β»ΒΉ",
" rexp (-x) * x ^ s / rexp ... | [
" (fun x => rexp (-x) * x ^ s) =o[atTop] fun x => rexp (-(1 / 2) * x)",
" rexp (-x) * x ^ s = 0",
" False",
" Tendsto (fun x => rexp (-x) * x ^ s / rexp (-(1 / 2) * x)) atTop (π 0)",
" (fun x => rexp (-x) * x ^ s / rexp (-(1 / 2) * x)) = (fun x => rexp (1 / 2 * x) / x ^ s)β»ΒΉ",
" rexp (-x) * x ^ s / rexp ... |
import Mathlib.Logic.Function.Basic
import Mathlib.Logic.Relator
import Mathlib.Init.Data.Quot
import Mathlib.Tactic.Cases
import Mathlib.Tactic.Use
import Mathlib.Tactic.MkIffOfInductiveProp
import Mathlib.Tactic.SimpRw
#align_import logic.relation from "leanprover-community/mathlib"@"3365b20c2ffa7c35e47e5209b89ba9a... | Mathlib/Logic/Relation.lean | 463 | 467 | theorem _root_.Acc.TransGen (h : Acc r a) : Acc (TransGen r) a := by |
induction' h with x _ H
refine Acc.intro x fun y hy β¦ ?_
cases' hy with _ hyx z _ hyz hzx
exacts [H y hyx, (H z hzx).inv hyz]
| [
" Acc (Relation.TransGen r) a",
" Acc (Relation.TransGen r) x",
" Acc (Relation.TransGen r) y"
] | [] |
import Mathlib.CategoryTheory.Limits.Shapes.Terminal
import Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts
#align_import category_theory.limits.shapes.strict_initial from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
universe v u
namespace CategoryTheory
namespace Limits
open C... | Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean | 206 | 237 | theorem limit_Ο_isIso_of_is_strict_terminal (F : J β₯€ C) [HasLimit F] (i : J)
(H : β (j) (_ : j β i), IsTerminal (F.obj j)) [Subsingleton (i βΆ i)] : IsIso (limit.Ο F i) := by |
classical
refine β¨β¨limit.lift _ β¨_, β¨?_, ?_β©β©, ?_, ?_β©β©
Β· exact fun j =>
dite (j = i)
(fun h => eqToHom (by cases h; rfl))
fun h => (H _ h).from _
Β· intro j k f
split_ifs with h h_1 h_1
Β· cases h
cases h_1
obtain rfl : f = π _ := Subsingleton.elim ... | [
" f = g",
" IsIso (limit.Ο F i)",
" (X : J) β ((Functor.const J).obj (F.toPrefunctor.1 i)).obj X βΆ F.obj X",
" ((Functor.const J).obj (F.toPrefunctor.1 i)).obj j = F.obj j",
" ((Functor.const J).obj (F.toPrefunctor.1 i)).obj i = F.obj i",
" β β¦X Y : Jβ¦ (f : X βΆ Y),\n (((Functor.const J).obj (F.toPrefun... | [
" f = g"
] |
import Mathlib.Data.Nat.Multiplicity
import Mathlib.Data.ZMod.Algebra
import Mathlib.RingTheory.WittVector.Basic
import Mathlib.RingTheory.WittVector.IsPoly
import Mathlib.FieldTheory.Perfect
#align_import ring_theory.witt_vector.frobenius from "leanprover-community/mathlib"@"0723536a0522d24fc2f159a096fb3304bef77472"... | Mathlib/RingTheory/WittVector/Frobenius.lean | 97 | 104 | theorem frobeniusPolyAux_eq (n : β) :
frobeniusPolyAux p n =
X (n + 1) - β i β range n,
β j β range (p ^ (n - i)),
(X i ^ p) ^ (p ^ (n - i) - (j + 1)) * frobeniusPolyAux p i ^ (j + 1) *
C β((p ^ (n - i)).choose (j + 1) / p ^ (n - i - v p β¨j + 1, Nat.succ_pos jβ©) *
... |
rw [frobeniusPolyAux, β Fin.sum_univ_eq_sum_range]
| [
" (bindβ (frobeniusPolyRat p)) (wittPolynomial p β n) = wittPolynomial p β (n + 1)",
" (bindβ fun n => (bindβ (wittPolynomial p β β fun n => n + 1)) (xInTermsOfW p β n)) (wittPolynomial p β n) =\n wittPolynomial p β (n + 1)",
" frobeniusPolyAux p n =\n X (n + 1) -\n β i β range n,\n β j β rang... | [
" (bindβ (frobeniusPolyRat p)) (wittPolynomial p β n) = wittPolynomial p β (n + 1)",
" (bindβ fun n => (bindβ (wittPolynomial p β β fun n => n + 1)) (xInTermsOfW p β n)) (wittPolynomial p β n) =\n wittPolynomial p β (n + 1)"
] |
import Mathlib.Topology.Order
#align_import topology.maps from "leanprover-community/mathlib"@"d91e7f7a7f1c7e9f0e18fdb6bde4f652004c735d"
open Set Filter Function
open TopologicalSpace Topology Filter
variable {X : Type*} {Y : Type*} {Z : Type*} {ΞΉ : Type*} {f : X β Y} {g : Y β Z}
section OpenMap
variable [Topo... | Mathlib/Topology/Maps.lean | 371 | 378 | theorem of_sections
(h : β x, β g : Y β X, ContinuousAt g (f x) β§ g (f x) = x β§ RightInverse g f) : IsOpenMap f :=
of_nhds_le fun x =>
let β¨g, hgc, hgx, hgfβ© := h x
calc
π (f x) = map f (map g (π (f x))) := by | rw [map_map, hgf.comp_eq_id, map_id]
_ β€ map f (π (g (f x))) := map_mono hgc
_ = map f (π x) := by rw [hgx]
| [
" IsOpen (id '' s)",
" IsOpen (g β f '' s)",
" IsOpen (g '' (f '' s))",
" IsOpen (range f)",
" IsOpen (f '' univ)",
" π (f x) = map f (map g (π (f x)))",
" map f (π (g (f x))) = map f (π x)"
] | [
" IsOpen (id '' s)",
" IsOpen (g β f '' s)",
" IsOpen (g '' (f '' s))",
" IsOpen (range f)",
" IsOpen (f '' univ)"
] |
import Mathlib.Logic.Equiv.Option
import Mathlib.Order.RelIso.Basic
import Mathlib.Order.Disjoint
import Mathlib.Order.WithBot
import Mathlib.Tactic.Monotonicity.Attr
import Mathlib.Util.AssertExists
#align_import order.hom.basic from "leanprover-community/mathlib"@"62a5626868683c104774de8d85b9855234ac807c"
open ... | Mathlib/Order/Hom/Basic.lean | 201 | 203 | theorem map_inv_lt_iff (f : F) {a : Ξ±} {b : Ξ²} : EquivLike.inv f b < a β b < f a := by |
rw [β map_lt_map_iff f]
simp only [EquivLike.apply_inv_apply]
| [
" EquivLike.inv f b < a β b < f a",
" f (EquivLike.inv f b) < f a β b < f a"
] | [] |
import Mathlib.LinearAlgebra.FiniteDimensional
import Mathlib.LinearAlgebra.FreeModule.Finite.Basic
import Mathlib.LinearAlgebra.FreeModule.StrongRankCondition
import Mathlib.LinearAlgebra.Projection
import Mathlib.LinearAlgebra.SesquilinearForm
import Mathlib.RingTheory.TensorProduct.Basic
import Mathlib.RingTheory.I... | Mathlib/LinearAlgebra/Dual.lean | 215 | 217 | theorem LinearMap.dualMap_id : (LinearMap.id : Mβ ββ[R] Mβ).dualMap = LinearMap.id := by |
ext
rfl
| [
" id.dualMap = id",
" (id.dualMap xβΒΉ) xβ = (id xβΒΉ) xβ"
] | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.