name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Meta.UnificationHint.noConfusionType | Lean.Meta.UnificationHint | Sort u → Lean.Meta.UnificationHint → Lean.Meta.UnificationHint → Sort u |
MeasureTheory.SimpleFunc.instNonUnitalNonAssocSemiring._proof_4 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : NonUnitalNonAssocSemiring β]
(a b c : MeasureTheory.SimpleFunc α β), (a + b) * c = a * c + b * c |
Complex.tanh_ofReal_im | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), (Complex.tanh ↑x).im = 0 |
Mathlib.Tactic.Abel.abelConv | Mathlib.Tactic.Abel | Lean.ParserDescr |
CategoryTheory.Limits.BinaryBicones.functoriality | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{D : Type uD} →
[inst_2 : CategoryTheory.Category.{uD', uD} D] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
(P Q : C) →
(F : CategoryTheory.Functor C D) →
[F.PreservesZeroMorphisms] →
CategoryTheory.Functor (CategoryTheory.Limits.BinaryBicone P Q)
(CategoryTheory.Limits.BinaryBicone (F.obj P) (F.obj Q)) |
Aesop.RappData.metaState | Aesop.Tree.Data | {Goal MVarCluster : Type} → Aesop.RappData Goal MVarCluster → Lean.Meta.SavedState |
AddValuation.comap_id | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀]
(v : AddValuation R Γ₀), AddValuation.comap (RingHom.id R) v = v |
_private.Mathlib.Geometry.Convex.Cone.Basic.0.ConvexCone.IsGenerating.isReproducing.match_1_4 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : AddCommGroup M] [inst_3 : Module R M]
{C : ConvexCone R M} (motive : (↑C).Nonempty → Prop) (hne : (↑C).Nonempty),
(∀ (c : M) (hc : c ∈ ↑C), motive ⋯) → motive hne |
Associated.neg_neg | Mathlib.Algebra.Ring.Associated | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : HasDistribNeg M] {a b : M}, Associated a b → Associated (-a) (-b) |
FirstOrder.Language.ElementaryEmbedding.toEmbedding._proof_2 | Mathlib.ModelTheory.ElementaryMaps | ∀ {L : FirstOrder.Language} {M : Type u_4} {N : Type u_3} [inst : L.Structure M] [inst_1 : L.Structure N]
(f : L.ElementaryEmbedding M N) {x : ℕ} (R : L.Relations x) (x_1 : Fin x → M),
FirstOrder.Language.Structure.RelMap R (⇑f ∘ x_1) ↔ FirstOrder.Language.Structure.RelMap R x_1 |
LinearMap.BilinForm.toLinHomAux₁ | Mathlib.LinearAlgebra.BilinearForm.Hom | {R : Type u_1} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → LinearMap.BilinForm R M → M → M →ₗ[R] R |
mabs_le | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b : G}, |a|ₘ ≤ b ↔ b⁻¹ ≤ a ∧ a ≤ b |
PresheafOfModules.Sheafify.map_smul_eq | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.obj)
[inst_1 : CategoryTheory.Presheaf.IsLocallyInjective J α] [inst_2 : CategoryTheory.Presheaf.IsLocallySurjective J α]
{M₀ : PresheafOfModules R₀} {A : CategoryTheory.Sheaf J AddCommGrpCat} (φ : M₀.presheaf ⟶ A.obj)
[inst_3 : CategoryTheory.Presheaf.IsLocallyInjective J φ] [inst_4 : CategoryTheory.Presheaf.IsLocallySurjective J φ]
{X : Cᵒᵖ} (r : ↑(R.obj.obj X)) (m : ↑(A.obj.obj X)) {Y : Cᵒᵖ} (f : X ⟶ Y) (r₀ : ↑(R₀.obj Y)),
(CategoryTheory.ConcreteCategory.hom (α.app Y)) r₀ = (CategoryTheory.ConcreteCategory.hom (R.obj.map f)) r →
∀ (m₀ : ↑(M₀.obj Y)),
(CategoryTheory.ConcreteCategory.hom (φ.app Y)) m₀ = (CategoryTheory.ConcreteCategory.hom (A.obj.map f)) m →
(CategoryTheory.ConcreteCategory.hom (A.obj.map f)) (PresheafOfModules.Sheafify.smul α φ r m) =
(CategoryTheory.ConcreteCategory.hom (φ.app Y)) (r₀ • m₀) |
Equiv.piCongrFiberwise_apply | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_9} {β : Type u_10} {γ₁ : α → Type u_11} {γ₂ : β → Type u_12} {f : α → β}
(e : (b : β) → ((σ : { a // f a = b }) → γ₁ ↑σ) ≃ γ₂ b) (g : (a : α) → γ₁ a) (b : β),
(Equiv.piCongrFiberwise e) g b = (e b) fun σ => g ↑σ |
continuous_inf_dom_left₂ | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u_5} {Y : Type u_6} {Z : Type u_7} {f : X → Y → Z} {ta1 ta2 : TopologicalSpace X}
{tb1 tb2 : TopologicalSpace Y} {tc1 : TopologicalSpace Z},
(Continuous fun p => f p.1 p.2) → Continuous fun p => f p.1 p.2 |
Int.fdiv_add_fmod' | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), b * a.fdiv b + a.fmod b = a |
CategoryTheory.IsReflexivePair.mk | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B : C} {f g : A ⟶ B},
(∃ s,
CategoryTheory.CategoryStruct.comp s f = CategoryTheory.CategoryStruct.id B ∧
CategoryTheory.CategoryStruct.comp s g = CategoryTheory.CategoryStruct.id B) →
CategoryTheory.IsReflexivePair f g |
MeasureTheory.IsSeparable | Mathlib.MeasureTheory.Measure.SeparableMeasure | {X : Type u_1} → [m : MeasurableSpace X] → MeasureTheory.Measure X → Prop |
one_lt_leOnePart._simp_2 | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] {a : α} [MulLeftMono α], a < 1 → (1 < a⁻ᵐ) = True |
Affine.Simplex.incenter_notMem_affineSpan_faceOpposite | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (i : Fin (n + 1)),
s.incenter ∉ affineSpan ℝ (Set.range (s.faceOpposite i).points) |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.mapZ_comp_assoc | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) {X Y X' Y' : C} {f : X ⟶ Y} {g : X' ⟶ Y'}
(φ : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g) {X'' Y'' : C} {h : X'' ⟶ Y''}
(ψ : CategoryTheory.Arrow.mk g ⟶ CategoryTheory.Arrow.mk h) {Z : C} (h_1 : (data.factorizationData h).Z ⟶ Z),
CategoryTheory.CategoryStruct.comp (data.mapZ (CategoryTheory.CategoryStruct.comp φ ψ)) h_1 =
CategoryTheory.CategoryStruct.comp (data.mapZ φ) (CategoryTheory.CategoryStruct.comp (data.mapZ ψ) h_1) |
AddMonoid.End.coe_one | Mathlib.Algebra.Group.Hom.Defs | ∀ (M : Type u_4) [inst : AddZero M], ⇑1 = id |
String.Slice.Pos.startInclusive_le_str | Init.Data.String.Basic | ∀ {s : String.Slice} {pos : s.Pos}, s.startInclusive ≤ pos.str |
CategoryTheory.IsExponentiable | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → [CategoryTheory.ChosenPullbacks C] → CategoryTheory.MorphismProperty C |
AddCommMonoid.zmodModule._proof_1 | Mathlib.Algebra.Module.ZMod | ∀ {n : ℕ} {M : Type u_1} [inst : AddCommMonoid M],
(∀ (x : M), n • x = 0) → ∀ (c : ℕ) (x : M), (c % n + c / n * n) • x = c • x → (c % n) • x = c • x |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.card_fixedPoints_modEq._simp_1_1 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b |
Filter.limsSup | Mathlib.Order.LiminfLimsup | {α : Type u_1} → [ConditionallyCompleteLattice α] → Filter α → α |
CategoryTheory.Limits.MultispanIndex.ι_fstSigmaMap_assoc | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) [inst_1 : CategoryTheory.Limits.HasCoproduct I.left]
[inst_2 : CategoryTheory.Limits.HasCoproduct I.right] (b : J.L) {Z : C} (h : ∐ I.right ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.left b)
(CategoryTheory.CategoryStruct.comp I.fstSigmaMap h) =
CategoryTheory.CategoryStruct.comp (I.fst b)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.right (J.fst b)) h) |
RCLike.continuous_ofReal | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], Continuous RCLike.ofReal |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rco.Internal.toList_eq_toList_iter | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.Rxo.IsAlwaysFinite α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α] {r : Std.Rco α},
r.toList = (Std.Rco.Internal.iter r).toList |
CategoryTheory.ShortComplex.SnakeInput.L₀X₂ToP_comp_pullback_snd | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.CategoryStruct.comp S.L₀X₂ToP (CategoryTheory.Limits.pullback.snd S.L₁.g S.v₀₁.τ₃) = S.L₀.g |
_private.Lean.Compiler.IR.SimpleGroundExpr.0.Lean.IR.compileToSimpleGroundExpr.compileFinalExpr._sparseCasesOn_13 | Lean.Compiler.IR.SimpleGroundExpr | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
AddEquiv.opOp | Mathlib.Algebra.Group.Equiv.Opposite | (M : Type u_3) → [inst : Add M] → M ≃+ Mᵃᵒᵖᵃᵒᵖ |
Finset.Nontrivial.instDecidablePred._proof_3 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} (h : Multiset.Nodup ⟦[]⟧), ¬{ val := ⟦[]⟧, nodup := h }.Nontrivial |
rootsOfUnityEquivNthRoots._proof_6 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ (R : Type u_1) (k : ℕ) [inst : NeZero k] [inst_1 : CommRing R] [inst_2 : IsDomain R]
(x : { x // x ∈ Polynomial.nthRoots k 1 }),
{ val := ↑x, inv := ↑x ^ (k - 1), val_inv := ⋯, inv_val := ⋯ } ∈ rootsOfUnity k R |
Action.diagonalSuccIsoTensorTrivial._proof_2 | Mathlib.CategoryTheory.Action.Monoidal | ∀ (G : Type u_1) [inst : Group G] (n : ℕ) (x : G),
CategoryTheory.CategoryStruct.comp
((Action.trivial G
(CategoryTheory.MonoidalCategoryStruct.tensorObj (Action.leftRegular G) (Action.trivial G (Fin n → G))).V).ρ
x)
(Fin.insertNthEquiv (fun x => G) 0).toIso.hom =
CategoryTheory.CategoryStruct.comp
((Action.trivial G
(CategoryTheory.MonoidalCategoryStruct.tensorObj (Action.leftRegular G) (Action.trivial G (Fin n → G))).V).ρ
x)
(Fin.insertNthEquiv (fun x => G) 0).toIso.hom |
Matrix.toBilin' | Mathlib.LinearAlgebra.Matrix.BilinearForm | {R₁ : Type u_1} →
[inst : CommSemiring R₁] →
{n : Type u_5} → [Fintype n] → [DecidableEq n] → Matrix n n R₁ ≃ₗ[R₁] LinearMap.BilinForm R₁ (n → R₁) |
PowerSeries.coeff_expand_mul | Mathlib.RingTheory.PowerSeries.Expand | ∀ {R : Type u_2} [inst : CommRing R] (p : ℕ) (hp : p ≠ 0) (φ : PowerSeries R) (m : ℕ),
(PowerSeries.coeff (p * m)) ((PowerSeries.expand p hp) φ) = (PowerSeries.coeff m) φ |
Lean.Meta.TransparencyMode._sizeOf_1 | Init.MetaTypes | Lean.Meta.TransparencyMode → ℕ |
instAddCommGroupUniformOnFun.eq_1 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : AddCommGroup β],
instAddCommGroupUniformOnFun = Pi.addCommGroup |
Order.Ioo_succ_right_eq_insert | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] {a b : α} [NoMaxOrder α],
a < b → Set.Ioo a (Order.succ b) = insert b (Set.Ioo a b) |
OrderIso.limsup_apply | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_6} [inst : ConditionallyCompleteLattice β]
[inst_1 : ConditionallyCompleteLattice γ] {f : Filter α} {u : α → β} (g : β ≃o γ),
autoParam (Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u) OrderIso.limsup_apply._auto_1 →
autoParam (Filter.IsCoboundedUnder (fun x1 x2 => x1 ≤ x2) f u) OrderIso.limsup_apply._auto_3 →
autoParam (Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f fun x => g (u x)) OrderIso.limsup_apply._auto_5 →
autoParam (Filter.IsCoboundedUnder (fun x1 x2 => x1 ≤ x2) f fun x => g (u x)) OrderIso.limsup_apply._auto_7 →
g (Filter.limsup u f) = Filter.limsup (fun x => g (u x)) f |
Stream'.WSeq.findIndexes.match_1 | Mathlib.Data.WSeq.Defs | {α : Type u_1} → (motive : α × ℕ → Sort u_2) → (x : α × ℕ) → ((a : α) → (n : ℕ) → motive (a, n)) → motive x |
Int.natAbs_natCast_sub_natCast_of_ge | Mathlib.Data.Int.NatAbs | ∀ {a b : ℕ}, b ≤ a → (↑a - ↑b).natAbs = a - b |
LinearMap.lcompₛₗ.eq_1 | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_14} {R₂ : Type u_15} {R₃ : Type u_16} (R₅ : Type u_18) {M : Type u_19} {N : Type u_20} (P : Type u_21)
[inst : Semiring R] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : Semiring R₅] {σ₁₂ : R →+* R₂}
(σ₂₃ : R₂ →+* R₃) {σ₁₃ : R →+* R₃} [inst_4 : AddCommMonoid M] [inst_5 : AddCommMonoid N] [inst_6 : AddCommMonoid P]
[inst_7 : Module R M] [inst_8 : Module R₂ N] [inst_9 : Module R₃ P] [inst_10 : Module R₅ P]
[inst_11 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [inst_12 : SMulCommClass R₃ R₅ P] (f : M →ₛₗ[σ₁₂] N),
LinearMap.lcompₛₗ R₅ P σ₂₃ f = (LinearMap.id.flip ∘ₛₗ f).flip |
CategoryTheory.Limits.WalkingMulticospan.instSmallCategory._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} {W X Y Z : CategoryTheory.Limits.WalkingMulticospan J} (f : W.Hom X)
(g : X.Hom Y) (h : Y.Hom Z), (f.comp g).comp h = f.comp (g.comp h) |
Subsemiring.topologicalClosure._proof_5 | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Semiring R] [inst_2 : IsTopologicalSemiring R]
(s : Subsemiring R) {a b : R},
a ∈ s.toAddSubmonoid.topologicalClosure.carrier →
b ∈ s.toAddSubmonoid.topologicalClosure.carrier → a + b ∈ s.toAddSubmonoid.topologicalClosure.carrier |
Mathlib.Linter.Style.lambdaSyntax.findLambdaSyntax | Mathlib.Tactic.Linter.Style | Lean.Syntax → Array Lean.Syntax |
Lean.Compiler.LCNF.Simp.CtorInfo.recOn | Lean.Compiler.LCNF.Simp.DiscrM | {motive : Lean.Compiler.LCNF.Simp.CtorInfo → Sort u} →
(t : Lean.Compiler.LCNF.Simp.CtorInfo) →
((val : Lean.ConstructorVal) →
(args : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) →
motive (Lean.Compiler.LCNF.Simp.CtorInfo.ctor val args)) →
((n : ℕ) → motive (Lean.Compiler.LCNF.Simp.CtorInfo.natVal n)) → motive t |
Lean.Elab.Do.elabDoTry._regBuiltin.Lean.Elab.Do.elabDoTry_1 | Lean.Elab.BuiltinDo.TryCatch | IO Unit |
Bool.not_bijective | Mathlib.Logic.Equiv.Bool | Function.Bijective not |
ContinuousLinearMap.rangeRestrict._proof_1 | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R₁ : Type u_3} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
[inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_1} [inst_4 : TopologicalSpace M₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂] [inst_8 : RingHomSurjective σ₁₂]
(f : M₁ →SL[σ₁₂] M₂) (x : M₁), ↑f x ∈ (↑f).range |
CategoryTheory.Limits.instDecidableEqWalkingParallelFamily._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_1}, CategoryTheory.Limits.WalkingParallelFamily.zero = CategoryTheory.Limits.WalkingParallelFamily.zero |
not_lt_of_ge | Mathlib.Order.Defs.PartialOrder | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ≤ b → ¬b < a |
groupCohomology.cochainsMap_id_f_map_mono | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A B : Rep k G} (φ : A ⟶ B) [CategoryTheory.Mono φ] (i : ℕ),
CategoryTheory.Mono ((groupCohomology.cochainsMap (MonoidHom.id G) φ).f i) |
CochainComplex.isoHomologyπ₀._proof_1 | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : CochainComplex C ℕ), K.d ((ComplexShape.up ℕ).prev 0) 0 = 0 |
map_prod | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : CommMonoid M] [inst_1 : CommMonoid N] {G : Type u_7}
[inst_2 : FunLike G M N] [MonoidHomClass G M N] (g : G) (f : ι → M) (s : Finset ι),
g (∏ x ∈ s, f x) = ∏ x ∈ s, g (f x) |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_extractLsb._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w hi lo i : ℕ},
i < hi - lo + 1 →
lo + (hi - lo + 1 - 1 - i) < w →
w - 1 - (lo + (hi - lo + 1 - 1 - i)) = w - 1 - (max hi lo - i) → ¬(i < hi - lo + 1 ∧ max hi lo - i < w) → False |
CochainComplex.shiftFunctorObjXIso.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K : CochainComplex C ℤ) (n i m : ℤ) (hm : m = i + n), K.shiftFunctorObjXIso n i m hm = K.shiftFunctorObjXIso n i m hm |
mabs_eq_max_inv | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Group α] [inst_1 : LinearOrder α] {a : α}, |a|ₘ = max a a⁻¹ |
CategoryTheory.EffectiveEpi.casesOn | Mathlib.CategoryTheory.EffectiveEpi.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X Y : C} →
{f : Y ⟶ X} →
{motive : CategoryTheory.EffectiveEpi f → Sort u} →
(t : CategoryTheory.EffectiveEpi f) →
((effectiveEpi : Nonempty (CategoryTheory.EffectiveEpiStruct f)) → motive ⋯) → motive t |
_private.Mathlib.Topology.Baire.Lemmas.0.Set.Finite.dense_sInter._simp_1_1 | Mathlib.Topology.Baire.Lemmas | ∀ {α : Type u} {P : α → Prop} {a : α} {s : Set α}, (∀ x ∈ insert a s, P x) = (P a ∧ ∀ x ∈ s, P x) |
Polynomial.degree.eq_1 | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R), p.degree = p.support.max |
Tactic.ComputeAsymptotics.BasisExtension.insert.sizeOf_spec | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | ∀ {basis : Tactic.ComputeAsymptotics.Basis} (f : ℝ → ℝ) (ex : Tactic.ComputeAsymptotics.BasisExtension basis),
sizeOf (Tactic.ComputeAsymptotics.BasisExtension.insert f ex) = 1 + sizeOf basis + sizeOf ex |
Lean.Lsp.MarkupKind.ctorElim | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.MarkupKind → Sort u} →
(ctorIdx : ℕ) → (t : Lean.Lsp.MarkupKind) → ctorIdx = t.ctorIdx → Lean.Lsp.MarkupKind.ctorElimType ctorIdx → motive t |
LieAlgebra.Orthogonal.indefiniteDiagonal_transform | Mathlib.Algebra.Lie.Classical | ∀ (p : Type u_2) (q : Type u_3) (R : Type u₂) [inst : DecidableEq p] [inst_1 : DecidableEq q] [inst_2 : CommRing R]
[inst_3 : Fintype p] [inst_4 : Fintype q] {i : R},
i * i = -1 →
(LieAlgebra.Orthogonal.Pso p q R i).transpose * LieAlgebra.Orthogonal.indefiniteDiagonal p q R *
LieAlgebra.Orthogonal.Pso p q R i =
1 |
Lean.Meta.DiscrTree.Key.proj.inj | Lean.Meta.DiscrTree.Types | ∀ {a : Lean.Name} {a_1 a_2 : ℕ} {a_3 : Lean.Name} {a_4 a_5 : ℕ},
Lean.Meta.DiscrTree.Key.proj a a_1 a_2 = Lean.Meta.DiscrTree.Key.proj a_3 a_4 a_5 → a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5 |
gcdMonoidOfLCM._proof_6 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] (lcm : α → α → α), (∀ (a b : α), a ∣ lcm a b) → ∀ (x : α), lcm 0 x = 0 |
LinearEquiv.injective | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
{σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂),
Function.Injective ⇑e |
CategoryTheory.Bicategory.LeftLift.alongId | Mathlib.CategoryTheory.Bicategory.Extension | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a c : B} → (g : c ⟶ a) → CategoryTheory.Bicategory.LeftLift (CategoryTheory.CategoryStruct.id a) g |
isSemilinearSet_iff | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Defs | ∀ {M : Type u_1} [inst : AddCommMonoid M] {s : Set M}, IsSemilinearSet s ↔ ∃ S, (∀ t ∈ S, IsLinearSet t) ∧ s = ⋃₀ ↑S |
Std.DTreeMap.Internal.Impl.Const.getEntryGT._sunfold | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
[Std.TransOrd α] →
(k : α) →
(t : Std.DTreeMap.Internal.Impl α fun x => β) → t.Ordered → (∃ a ∈ t, compare a k = Ordering.gt) → α × β |
Set.exists_mem_notMem_of_ncard_lt_ncard | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α},
s.ncard < t.ncard → autoParam s.Finite Set.exists_mem_notMem_of_ncard_lt_ncard._auto_1 → ∃ e ∈ t, e ∉ s |
Finset.nonempty_Ioc._simp_1 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α], (Finset.Ioc a b).Nonempty = (a < b) |
_private.Mathlib.Analysis.SpecialFunctions.Integrability.Basic.0.intervalIntegral.intervalIntegrable_inv_one_add_sq._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Integrability.Basic | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G), a⁻¹ = 1 / a |
CategoryTheory.Functor.mapCochainComplexShiftIso._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u_2}
[inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.Preadditive D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Additive] (n : ℤ) (K : HomologicalComplex C (ComplexShape.up ℤ))
(i j : ℤ),
(ComplexShape.up ℤ).Rel i j →
CategoryTheory.CategoryStruct.comp
((fun x =>
CategoryTheory.Iso.refl
((((CategoryTheory.shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n).comp
(F.mapHomologicalComplex (ComplexShape.up ℤ))).obj
K).X
x))
i).hom
((((F.mapHomologicalComplex (ComplexShape.up ℤ)).comp
(CategoryTheory.shiftFunctor (HomologicalComplex D (ComplexShape.up ℤ)) n)).obj
K).d
i j) =
CategoryTheory.CategoryStruct.comp
((((CategoryTheory.shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n).comp
(F.mapHomologicalComplex (ComplexShape.up ℤ))).obj
K).d
i j)
((fun x =>
CategoryTheory.Iso.refl
((((CategoryTheory.shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n).comp
(F.mapHomologicalComplex (ComplexShape.up ℤ))).obj
K).X
x))
j).hom |
Action.forget_δ | Mathlib.CategoryTheory.Action.Monoidal | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G]
[inst_2 : CategoryTheory.MonoidalCategory V] (X Y : Action V G),
CategoryTheory.Functor.OplaxMonoidal.δ (Action.forget V G) X Y =
CategoryTheory.CategoryStruct.id ((Action.forget V G).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)) |
ContinuousMonoidHom.instCoeOutOfMonoidHomClassOfContinuousMapClass | Mathlib.Topology.Algebra.ContinuousMonoidHom | {A : Type u_2} →
{B : Type u_3} →
[inst : Monoid A] →
[inst_1 : Monoid B] →
[inst_2 : TopologicalSpace A] →
[inst_3 : TopologicalSpace B] →
{F : Type u_7} →
[inst_4 : FunLike F A B] → [MonoidHomClass F A B] → [ContinuousMapClass F A B] → CoeOut F (A →ₜ* B) |
CategoryTheory.MorphismProperty.Over.isoMk._proof_3 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {P Q : CategoryTheory.MorphismProperty T} {X : T}
{A B : P.Over Q X} (f : A.left ≅ B.left),
CategoryTheory.CategoryStruct.comp f.hom B.hom = A.hom →
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id T).map f.hom) B.hom =
CategoryTheory.CategoryStruct.comp A.hom
((CategoryTheory.Functor.fromPUnit X).map (CategoryTheory.Discrete.eqToIso' ⋯).hom) |
_private.Init.Data.Int.LemmasAux.0.Int.ble'_eq_true._proof_1_4 | Init.Data.Int.LemmasAux | ∀ (a a_1 : ℕ), ¬(a_1 ≤ a ↔ Int.negSucc a ≤ Int.negSucc a_1) → False |
Std.TreeMap.getKeyD_minKey? | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {km fallback : α},
t.minKey? = some km → t.getKeyD km fallback = km |
ZMod.valMinAbs_natAbs_eq_min | Mathlib.Data.ZMod.ValMinAbs | ∀ {n : ℕ} [hpos : NeZero n] (a : ZMod n), a.valMinAbs.natAbs = min a.val (n - a.val) |
List.Sorted.decide | Mathlib.Data.List.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} [inst : DecidableRel R] (l : List α),
List.Pairwise R l → List.Pairwise (fun a b => decide (R a b) = true) l |
Std.HashMap.isEmpty_inter_right | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α],
m₂.isEmpty = true → (m₁ ∩ m₂).isEmpty = true |
instConditionallyCompleteLatticeTropical._proof_3 | Mathlib.Algebra.Tropical.Lattice | ∀ {R : Type u_1} [inst : ConditionallyCompleteLattice R] (_s : Set (Tropical R)) (_x : Tropical R),
BddBelow _s → _x ∈ _s → sInf (Tropical.untrop '' _s) ≤ Tropical.untrop _x |
Lean.getAttrParamOptPrio | Lean.Attributes | Lean.Syntax → Lean.AttrM ℕ |
CategoryTheory.Preadditive.mono_iff_injective | Mathlib.Algebra.Homology.ShortComplex.ConcreteCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type w}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC]
[inst_3 : CategoryTheory.HasForget₂ C Ab] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : (CategoryTheory.forget₂ C Ab).Additive] [(CategoryTheory.forget₂ C Ab).PreservesHomology]
[CategoryTheory.Limits.HasZeroObject C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.Mono f ↔
Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom ((CategoryTheory.forget₂ C Ab).map f)) |
ArchimedeanClass.FiniteElement._proof_2 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ (K : Type u_1) [inst : LinearOrder K] [inst_1 : Field K] [IsOrderedRing K], IsStrictOrderedRing K |
CategoryTheory.HasDetector.casesOn | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{motive : CategoryTheory.HasDetector C → Sort u} →
(t : CategoryTheory.HasDetector C) → ((hasDetector : ∃ G, CategoryTheory.IsDetector G) → motive ⋯) → motive t |
isIrreducible_iff_sInter | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X},
IsIrreducible s ↔ ∀ (U : Finset (Set X)), (∀ u ∈ U, IsOpen u) → (∀ u ∈ U, (s ∩ u).Nonempty) → (s ∩ ⋂₀ ↑U).Nonempty |
derivWithin_const_smul | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {s : Set 𝕜} {R : Type u_2} [inst_3 : Monoid R]
[inst_4 : DistribMulAction R F] [SMulCommClass 𝕜 R F] [ContinuousConstSMul R F] (c : R),
DifferentiableWithinAt 𝕜 f s x → derivWithin (c • f) s x = c • derivWithin f s x |
TendstoLocallyUniformlyOn.comp | Mathlib.Topology.UniformSpace.LocallyUniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β]
{F : ι → α → β} {f : α → β} {s : Set α} {p : Filter ι} [inst_2 : TopologicalSpace γ] {t : Set γ},
TendstoLocallyUniformlyOn F f p s →
∀ (g : γ → α), Set.MapsTo g t s → ContinuousOn g t → TendstoLocallyUniformlyOn (fun n => F n ∘ g) (f ∘ g) p t |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_roc_add_succ_right_eq_push._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, ¬m ≤ m + n → False |
Lean.KeyedDeclsAttribute.AttributeEntry.ctorIdx | Lean.KeyedDeclsAttribute | {γ : Type} → Lean.KeyedDeclsAttribute.AttributeEntry γ → ℕ |
CategoryTheory.Pretriangulated.Opposite.rotateTriangleOpEquivalenceInverseObjRotateUnopIso._proof_4 | Mathlib.CategoryTheory.Triangulated.Opposite.Pretriangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Preadditive C] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
(T : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ),
CategoryTheory.CategoryStruct.comp
(Opposite.unop ((CategoryTheory.Pretriangulated.triangleOpEquivalence C).inverse.obj T.rotate)).rotate.mor₂
(-((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C 1).unitIso.app T.obj₁).unop).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl
(Opposite.unop
((CategoryTheory.Pretriangulated.triangleOpEquivalence C).inverse.obj T.rotate)).rotate.obj₂).hom
(Opposite.unop ((CategoryTheory.Pretriangulated.triangleOpEquivalence C).inverse.obj T)).mor₂ |
_private.Mathlib.RingTheory.KrullDimension.Regular.0.ringKrullDim_quotient_span_singleton_succ_eq_ringKrullDim_of_mem_jacobson._simp_1_1 | Mathlib.RingTheory.KrullDimension.Regular | ∀ {R : Type u} {M : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (r : R)
(N : Submodule R M), r • N = Ideal.span {r} • N |
Metric.Snowflaking.instT2Space | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : TopologicalSpace X] [T2Space X],
T2Space (Metric.Snowflaking X α hα₀ hα₁) |
LinearMap.BilinMap.tmul | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | {R : Type uR} →
{A : Type uA} →
{M₁ : Type uM₁} →
{M₂ : Type uM₂} →
{N₁ : Type uN₁} →
{N₂ : Type uN₂} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring A] →
[inst_2 : AddCommMonoid M₁] →
[inst_3 : AddCommMonoid M₂] →
[inst_4 : AddCommMonoid N₁] →
[inst_5 : AddCommMonoid N₂] →
[inst_6 : Algebra R A] →
[inst_7 : Module R M₁] →
[inst_8 : Module A M₁] →
[inst_9 : Module R N₁] →
[inst_10 : Module A N₁] →
[inst_11 : SMulCommClass R A M₁] →
[IsScalarTower R A M₁] →
[inst_13 : SMulCommClass R A N₁] →
[IsScalarTower R A N₁] →
[inst_15 : Module R M₂] →
[inst_16 : Module R N₂] →
LinearMap.BilinMap A M₁ N₁ →
LinearMap.BilinMap R M₂ N₂ →
LinearMap.BilinMap A (TensorProduct R M₁ M₂) (TensorProduct R N₁ N₂) |
ENNReal.toNNReal_natCast_eq_toNNReal | Mathlib.Data.ENNReal.Basic | ∀ (n : ℕ), (↑n).toNNReal = (↑n).toNNReal |
Cardinal.lift_eq_zero | Mathlib.SetTheory.Cardinal.Order | ∀ {a : Cardinal.{v}}, Cardinal.lift.{u, v} a = 0 ↔ a = 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.