name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Fin.partialSum | Mathlib.Algebra.BigOperators.Fin | {M : Type u_2} → [AddMonoid M] → {n : ℕ} → (Fin n → M) → Fin (n + 1) → M | true |
List.map_rightInverse_iff._simp_1 | Mathlib.Data.List.Basic | ∀ {α : Type u} {β : Type v} {f : α → β} {g : β → α},
Function.RightInverse (List.map f) (List.map g) = Function.RightInverse f g | false |
_private.Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings.0.NumberField.Embeddings.finite_of_norm_le._simp_1_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
Lean.CollectLevelParams.State.visitedLevel | Lean.Util.CollectLevelParams | Lean.CollectLevelParams.State → Lean.LevelSet | true |
CategoryTheory.MorphismProperty.instHasTwoOutOfThreePropertyOppositeOp | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C)
[W.HasTwoOutOfThreeProperty], W.op.HasTwoOutOfThreeProperty | true |
IsometryClass.mk | Mathlib.Topology.MetricSpace.Isometry | ∀ {F : Type u_3} {α : outParam (Type u_4)} {β : outParam (Type u_5)} [inst : PseudoEMetricSpace α]
[inst_1 : PseudoEMetricSpace β] [inst_2 : FunLike F α β], (∀ (f : F), Isometry ⇑f) → IsometryClass F α β | true |
_private.Std.Data.Iterators.Lemmas.Combinators.TakeWhile.0.Std.Iter.step_takeWhile.match_3.eq_2 | Std.Data.Iterators.Lemmas.Combinators.TakeWhile | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {it : Std.Iter β} (motive : it.Step → Sort u_2) (it' : Std.Iter β)
(h : it.IsPlausibleStep (Std.IterStep.skip it'))
(h_1 :
(it' : Std.Iter β) →
(out : β) → (h : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.IterStep.yield it' out, h⟩)
(h_2 : (it' : Std.Iter β) → (h : it.IsPlausibleStep (Std.IterStep.skip it')) → motive ⟨Std.IterStep.skip it', h⟩)
(h_3 : (h : it.IsPlausibleStep Std.IterStep.done) → motive ⟨Std.IterStep.done, h⟩),
(match ⟨Std.IterStep.skip it', h⟩ with
| ⟨Std.IterStep.yield it' out, h⟩ => h_1 it' out h
| ⟨Std.IterStep.skip it', h⟩ => h_2 it' h
| ⟨Std.IterStep.done, h⟩ => h_3 h) =
h_2 it' h | true |
Lean.Server.Reference.mk._flat_ctor | Lean.Server.References | Lean.Lsp.RefIdent →
Array Lean.Lsp.RefIdent →
Lean.Lsp.Range → Lean.Syntax → Lean.Elab.ContextInfo → Lean.Elab.Info → Bool → Lean.Server.Reference | false |
Array.getElem_zipWith | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {xs : Array α} {ys : Array β} {f : α → β → γ} {i : ℕ}
(hi : i < (Array.zipWith f xs ys).size), (Array.zipWith f xs ys)[i] = f xs[i] ys[i] | true |
LLVM.Linkage.linkerPrivate | Lean.Compiler.IR.LLVMBindings | LLVM.Linkage | true |
CategoryTheory.Discrete.monoidal._proof_8 | Mathlib.CategoryTheory.Monoidal.Discrete | ∀ (M : Type u_1) [inst : Monoid M] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : CategoryTheory.Discrete M} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂)
(g₁ : Y₁ ⟶ Z₁) (g₂ : Y₂ ⟶ Z₂),
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (CategoryTheory.eqToHom ⋯) = CategoryTheory.eqToHom ⋯ | false |
_private.Aesop.Tree.Data.0.Aesop.NodeState.isIrrelevant.match_1 | Aesop.Tree.Data | (motive : Aesop.NodeState → Sort u_1) →
(x : Aesop.NodeState) →
(Unit → motive Aesop.NodeState.proven) →
(Unit → motive Aesop.NodeState.unprovable) → (Unit → motive Aesop.NodeState.unknown) → motive x | false |
continuousOn_cfcₙ._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | false |
Matrix.addZeroClass | Mathlib.LinearAlgebra.Matrix.Defs | {m : Type u_2} → {n : Type u_3} → {α : Type v} → [AddZeroClass α] → AddZeroClass (Matrix m n α) | true |
_private.Mathlib.Topology.IndicatorConstPointwise.0.tendsto_indicator_const_apply_iff_eventually'._simp_1_1 | Mathlib.Topology.IndicatorConstPointwise | ∀ {α : Type u_1} {f g : Filter α}, (f ≤ g) = ∀ x ∈ g, x ∈ f | false |
Lean.ParseImports.State.mk.sizeOf_spec | Lean.Elab.ParseImportsFast | ∀ (imports : Array Lean.Import) (pos : String.Pos.Raw) (badModifier : Bool) (error? : Option String)
(isModule isMeta isExported importAll : Bool),
sizeOf
{ imports := imports, pos := pos, badModifier := badModifier, error? := error?, isModule := isModule,
isMeta := isMeta, isExported := isExported, importAll := importAll } =
1 + sizeOf imports + sizeOf pos + sizeOf badModifier + sizeOf error? + sizeOf isModule + sizeOf isMeta +
sizeOf isExported +
sizeOf importAll | true |
MvPolynomial.totalDegree_zero_iff_isHomogeneous | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ (σ : Type u_1) {R : Type u_3} [inst : CommSemiring R] {p : MvPolynomial σ R}, p.totalDegree = 0 ↔ p.IsHomogeneous 0 | true |
Locale.coe_of | Mathlib.Topology.Category.Locale | ∀ (α : Type u_1) [inst : Order.Frame α], ↑(Opposite.unop (Locale.of α)) = α | true |
CategoryTheory.Limits.IsInitial.uniqueUpToIso._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I I' : C} (hI : CategoryTheory.Limits.IsInitial I)
(hI' : CategoryTheory.Limits.IsInitial I'),
CategoryTheory.CategoryStruct.comp (hI.to I') (hI'.to I) = CategoryTheory.CategoryStruct.id I | false |
Lean.Language.DynamicSnapshot.ctorIdx | Lean.Language.Basic | Lean.Language.DynamicSnapshot → ℕ | false |
instFieldGaloisField._aux_59 | Mathlib.FieldTheory.Finite.GaloisField | (p : ℕ) → [inst : Fact (Nat.Prime p)] → (n : ℕ) → ℚ≥0 → GaloisField p n | false |
ProjectiveSpectrum.zeroLocus_mul_homogeneousIdeal | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] (I J : HomogeneousIdeal 𝒜),
ProjectiveSpectrum.zeroLocus 𝒜 ↑(I * J) = ProjectiveSpectrum.zeroLocus 𝒜 ↑I ∪ ProjectiveSpectrum.zeroLocus 𝒜 ↑J | true |
CategoryTheory.Abelian.PreservesCoimage.iso_hom_π | Mathlib.CategoryTheory.Limits.Preserves.Shapes.AbelianImages | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(F : CategoryTheory.Functor C D) [inst_4 : F.PreservesZeroMorphisms] {X Y : C} (f : X ⟶ Y)
[inst_5 : CategoryTheory.Limits.HasKernel f]
[inst_6 : CategoryTheory.Limits.HasCokernel (CategoryTheory.Limits.kernel.ι f)]
[inst_7 : CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.parallelPair f 0) F]
[inst_8 :
CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair (CategoryTheory.Limits.kernel.ι f) 0) F]
[inst_9 : CategoryTheory.Limits.HasKernel (F.map f)]
[inst_10 : CategoryTheory.Limits.HasCokernel (CategoryTheory.Limits.kernel.ι (F.map f))],
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Abelian.coimage.π f))
(CategoryTheory.Abelian.PreservesCoimage.iso F f).hom =
CategoryTheory.Abelian.coimage.π (F.map f) | true |
NonUnitalStarAlgHom.rangeRestrict | Mathlib.Algebra.Star.NonUnitalSubalgebra | {F : Type v'} →
{R : Type u} →
{A : Type v} →
{B : Type w} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : Module R A] →
[inst_3 : Star A] →
[inst_4 : NonUnitalNonAssocSemiring B] →
[inst_5 : Module R B] →
[inst_6 : Star B] →
[inst_7 : FunLike F A B] →
[inst_8 : NonUnitalAlgHomClass F R A B] →
[inst_9 : StarHomClass F A B] → (f : F) → A →⋆ₙₐ[R] ↥(NonUnitalStarAlgHom.range f) | true |
act_rel_act_of_rel_of_rel | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ {N : Type u_2} {r : N → N → Prop} {mu : N → N → N} [IsTrans N r] [i : CovariantClass N N mu r]
[i' : CovariantClass N N (Function.swap mu) r] {a b c d : N}, r a b → r c d → r (mu a c) (mu b d) | true |
CategoryTheory.ObjectProperty.small_unop_iff._simp_1 | Mathlib.CategoryTheory.ObjectProperty.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty Cᵒᵖ),
CategoryTheory.ObjectProperty.Small.{w, v, u} P.unop = CategoryTheory.ObjectProperty.Small.{w, v, u} P | false |
_private.Mathlib.Algebra.Polynomial.Roots.0.Polynomial.nthRoots_two_eq_zero_iff._simp_1_4 | Mathlib.Algebra.Polynomial.Roots | ∀ {α : Sort u_1} {p : α → Prop}, (∀ (x : α), ¬p x) = ¬∃ x, p x | false |
BigOperators.delabFinsetSum | Mathlib.Algebra.BigOperators.Group.Finset.Defs | Lean.PrettyPrinter.Delaborator.Delab | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.getMatchEqCondForAux.handleSimpleEnum | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | Lean.Name → Lean.Name → Lean.InductiveVal → Array Lean.ConstructorVal → Lean.MetaM Lean.Declaration | true |
MeasureTheory.eLpNormEssSup_const_smul_le' | Mathlib.MeasureTheory.Function.LpSeminorm.SMul | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {𝕜 : Type u_3} [inst : NormedRing 𝕜]
{ε : Type u_4} [inst_1 : TopologicalSpace ε] [inst_2 : ESeminormedAddMonoid ε] [inst_3 : SMul 𝕜 ε]
[ENormSMulClass 𝕜 ε] {c : 𝕜} {f : α → ε},
MeasureTheory.eLpNormEssSup (c • f) μ ≤ ‖c‖ₑ * MeasureTheory.eLpNormEssSup f μ | true |
_private.Mathlib.RingTheory.Ideal.Pure.0.injective_lTensor_quotient_iff_inf_eq_mul._simp_1_6 | Mathlib.RingTheory.Ideal.Pure | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_7} [inst : Ring R] [inst_1 : Ring R₂]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂}, Function.Injective ⇑f = (f.ker = ⊥) | false |
ComplexShape.symmetryEquiv.match_1 | Mathlib.Algebra.Homology.ComplexShapeSigns | {I₁ : Type u_1} →
{I₂ : Type u_2} →
{I₁₂ : Type u_3} →
(c₁ : ComplexShape I₁) →
(c₂ : ComplexShape I₂) →
(c₁₂ : ComplexShape I₁₂) →
[inst : TotalComplexShape c₂ c₁ c₁₂] →
(j : I₁₂) →
(motive : ↑(c₂.π c₁ c₁₂ ⁻¹' {j}) → Sort u_4) →
(x : ↑(c₂.π c₁ c₁₂ ⁻¹' {j})) →
((i₂ : I₂) → (i₁ : I₁) → (h : (i₂, i₁) ∈ c₂.π c₁ c₁₂ ⁻¹' {j}) → motive ⟨(i₂, i₁), h⟩) → motive x | false |
CategoryTheory.PreGaloisCategory.endEquivSectionsFibers_π | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) [inst_2 : CategoryTheory.PreGaloisCategory.FiberFunctor F]
(f : CategoryTheory.End F) (A : CategoryTheory.PreGaloisCategory.PointedGaloisObject F),
↑((CategoryTheory.PreGaloisCategory.endEquivSectionsFibers F) f) A =
(CategoryTheory.ConcreteCategory.hom (f.app A.obj)) A.pt | true |
Std.PRange.instHasSizeInt_1 | Init.Data.Range.Polymorphic.Int | Std.Rxo.HasSize ℤ | true |
instDecidableEqDyckWord.decEq._proof_1 | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ (a : List DyckStep) (a_1 : List.count DyckStep.U a = List.count DyckStep.D a), a_1 = a_1 | false |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.D | Std.Time.Format.Basic | Std.Time.GenericFormat.DateBuilder✝ → Option (Sigma Std.Time.Day.Ordinal.OfYear) | true |
Lean.Widget.GetWidgetsResponse.mk.inj | Lean.Widget.UserWidget | ∀ {widgets widgets_1 : Array Lean.Widget.PanelWidgetInstance},
{ widgets := widgets } = { widgets := widgets_1 } → widgets = widgets_1 | true |
Set.Nontrivial.add_left | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Add α] [IsLeftCancelAdd α] {s t : Set α}, t.Nontrivial → s.Nonempty → (s + t).Nontrivial | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.i₀_le | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {ι : Type u_2} {κ : Type u_3} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) (r r' : ℤ) (pq : κ)
(hrr' : autoParam (r + 1 = r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.i₀_le._auto_1)
(hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.i₀_le._auto_3),
data.i₀ r' pq ⋯ ≤ data.i₀ r pq ⋯ | true |
MeasureTheory.AddContent.onIoc._proof_16 | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} [inst : LinearOrder α] {G : Type u_2} [inst_1 : AddCommGroup G] (f : α → G) (I : Finset (Set α)),
↑I ⊆ {s | ∃ u v, u ≤ v ∧ s = Set.Ioc u v} →
(↑I).PairwiseDisjoint id →
⋃₀ ↑I ∈ {s | ∃ u v, u ≤ v ∧ s = Set.Ioc u v} →
MeasureTheory.AddContent.onIocAux f (⋃₀ ↑I) = ∑ u ∈ I, MeasureTheory.AddContent.onIocAux f u | false |
Std.HashMap.getElem_inter | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {h_mem : k ∈ m₁ ∩ m₂}, (m₁ ∩ m₂)[k] = m₁[k] | true |
Mathlib.Tactic.Order.AtomicFact.isBot | Mathlib.Tactic.Order.CollectFacts | ℕ → Mathlib.Tactic.Order.AtomicFact | true |
Polynomial.coeff_X_one | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R], Polynomial.X.coeff 1 = 1 | true |
MulSemiringAction.smul_mul | Mathlib.Algebra.Ring.Action.Basic | ∀ {M : Type u} {R : Type v} {inst : Monoid M} {inst_1 : Semiring R} [self : MulSemiringAction M R] (g : M) (x y : R),
g • (x * y) = g • x * g • y | true |
_private.Init.Data.Iterators.Basic.0.Std.Internal.idOpaque | Init.Data.Iterators.Basic | {α : Sort u_1} → { f // f = id } | true |
_private.Mathlib.Data.Nat.Factorization.Basic.0.Nat.Icc_factorization_eq_pow_dvd._simp_1_2 | Mathlib.Data.Nat.Factorization.Basic | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | false |
CategoryTheory.BasedCategory.recOn | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | {𝒮 : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
{motive : CategoryTheory.BasedCategory 𝒮 → Sort u} →
(t : CategoryTheory.BasedCategory 𝒮) →
((obj : Type u₂) →
(category : CategoryTheory.Category.{v₂, u₂} obj) →
(p : CategoryTheory.Functor obj 𝒮) → motive { obj := obj, category := category, p := p }) →
motive t | false |
Submodule.torsionBy_isTorsionBy | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (a : R),
Module.IsTorsionBy R (↥(Submodule.torsionBy R M a)) a | true |
_private.Mathlib.Algebra.Algebra.Spectrum.Basic.0.resolventSet_neg._simp_1_1 | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {α : Type u_2} [inst : Neg α] {s : Set α} {a : α}, (a ∈ -s) = (-a ∈ s) | false |
RestrictedProduct.ext | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) (A : (i : ι) → Set (R i)) {𝓕 : Filter ι}
{x y : RestrictedProduct (fun i => R i) (fun i => A i) 𝓕}, (∀ (i : ι), x i = y i) → x = y | true |
Left.self_le_inv | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : Preorder α] [MulLeftMono α] {a : α}, a ≤ 1 → a ≤ a⁻¹ | true |
_private.Lean.Parser.Level.0.Lean.Parser.initFn._@.Lean.Parser.Level.2271617841._hygCtx._hyg.2 | Lean.Parser.Level | IO Unit | false |
CategoryTheory.Limits.StrongEpiMonoFactorisation._sizeOf_inst | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{X Y : C} → (f : X ⟶ Y) → [SizeOf C] → SizeOf (CategoryTheory.Limits.StrongEpiMonoFactorisation f) | false |
ENNReal.instAddCommMonoid._proof_1 | Mathlib.Data.ENNReal.Basic | ∀ (a b : ENNReal), a + b = b + a | false |
Mathlib.Tactic.Linarith.CompSource.scale.injEq | Mathlib.Tactic.Linarith.Oracle.FourierMotzkin | ∀ (a : ℕ) (a_1 : Mathlib.Tactic.Linarith.CompSource) (a_2 : ℕ) (a_3 : Mathlib.Tactic.Linarith.CompSource),
(Mathlib.Tactic.Linarith.CompSource.scale a a_1 = Mathlib.Tactic.Linarith.CompSource.scale a_2 a_3) =
(a = a_2 ∧ a_1 = a_3) | true |
AlgebraicGeometry.AffineSpace.toSpecMvPolyIntEquiv | Mathlib.AlgebraicGeometry.AffineSpace | (n : Type v) →
{X : AlgebraicGeometry.Scheme} →
(X ⟶ AlgebraicGeometry.Spec (CommRingCat.of (MvPolynomial n (ULift.{u, 0} ℤ)))) ≃
(n → ↑(X.presheaf.obj (Opposite.op ⊤))) | true |
Std.DTreeMap.Raw.instSliceableRocSlice._auto_1 | Std.Data.DTreeMap.Raw.Slice | Lean.Syntax | false |
TopCat.prodBinaryFan | Mathlib.Topology.Category.TopCat.Limits.Products | (X Y : TopCat) → CategoryTheory.Limits.BinaryFan X Y | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.IsAdmissible.simplicialEvalσ_succ_getElem._proof_1_4 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | ∀ (head : ℕ) (tail : List ℕ) {k : ℕ}, k + 1 ≤ (head :: tail).length → k < (head :: tail).length | false |
MeasureTheory.trim_trim | Mathlib.MeasureTheory.Measure.Trim | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {m₁ m₂ : MeasurableSpace α} {hm₁₂ : m₁ ≤ m₂}
{hm₂ : m₂ ≤ m0}, (μ.trim hm₂).trim hm₁₂ = μ.trim ⋯ | true |
Module.Basis.finiteDimensional_of_finite | Mathlib.LinearAlgebra.FiniteDimensional.Defs | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {ι : Type w}
[Finite ι] (h : Module.Basis ι K V), FiniteDimensional K V | true |
Submodule.idemSemiring._proof_7 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : Algebra R A]
(a b c : Submodule R A), a * b * c = a * (b * c) | false |
Std.Sat.AIG.relabelNat'_fst_eq_relabelNat | Std.Sat.AIG.RelabelNat | ∀ {α : Type} [inst : DecidableEq α] [inst_1 : Hashable α] {aig : Std.Sat.AIG α}, aig.relabelNat'.1 = aig.relabelNat | true |
Real.instNormedAddCommGroupAngle._proof_44 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | autoParam (uniformity Real.Angle = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | dist p.1 p.2 < ε})
PseudoMetricSpace.uniformity_dist._autoParam | false |
CategoryTheory.ShortComplex.homologyπ.eq_1 | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasHomology],
S.homologyπ = CategoryTheory.CategoryStruct.comp S.leftHomologyπ S.leftHomologyIso.hom | true |
inv_le_div_iff_le_mul' | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : CommGroup α] [inst_1 : LE α] [MulLeftMono α] {a b c : α}, a⁻¹ ≤ b / c ↔ c ≤ a * b | true |
CategoryTheory.Limits.PullbackCone.isLimitOfCompMono | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Mono | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W X Y Z : C} →
(f : X ⟶ W) →
(g : Y ⟶ W) →
(i : W ⟶ Z) →
[CategoryTheory.Mono i] →
(s : CategoryTheory.Limits.PullbackCone f g) →
CategoryTheory.Limits.IsLimit s →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.PullbackCone.mk s.fst s.snd ⋯) | true |
_private.Mathlib.Order.WithBot.0.WithBot.unbotD_eq_self_iff._simp_1_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} {d y : α} {x : WithBot α}, (WithBot.unbotD d x = y) = (x = ↑y ∨ x = ⊥ ∧ y = d) | false |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.Hom.mk.sizeOf_spec | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {X : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} X] {x y : CategoryTheory.Limits.CategoricalPullback.CatCommSqOver F G X}
[inst_4 : SizeOf A] [inst_5 : SizeOf B] [inst_6 : SizeOf C] [inst_7 : SizeOf X] (fst : x.fst ⟶ y.fst)
(snd : x.snd ⟶ y.snd)
(w :
autoParam
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.whiskerRight fst F) y.iso.hom =
CategoryTheory.CategoryStruct.comp x.iso.hom (CategoryTheory.Functor.whiskerRight snd G))
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.Hom.w._autoParam),
sizeOf { fst := fst, snd := snd, w := w } = 1 + sizeOf fst + sizeOf snd + sizeOf w | true |
_private.Mathlib.Combinatorics.Graph.Basic.0.Graph.banana_isLoopAt._simp_1_2 | Mathlib.Combinatorics.Graph.Basic | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | false |
ULift.monoidWithZero | Mathlib.Algebra.GroupWithZero.ULift | {α : Type u} → [MonoidWithZero α] → MonoidWithZero (ULift.{u_1, u} α) | true |
CategoryTheory.Limits.diagonalObjPullbackFstIso_hom_fst_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) {Z_1 : C} (h : Y ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.diagonalObjPullbackFstIso f g).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.fst
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd g g) g) f)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd g g) h)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst f g)
(CategoryTheory.Limits.pullback.fst f g))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd f g) h) | true |
_private.Mathlib.CategoryTheory.Sites.Coverage.0.CategoryTheory.Coverage.eq_top_pullback._simp_1_1 | Mathlib.CategoryTheory.Sites.Coverage | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X), ⊤.1 f = True | false |
DividedPowers.subDPIdeal_inf_of_quot | Mathlib.RingTheory.DividedPowers.SubDPIdeal | {A : Type u_2} →
[inst : CommRing A] →
{I : Ideal A} →
{hI : DividedPowers I} →
{J : Ideal A} →
{hJ : DividedPowers (Ideal.map (Ideal.Quotient.mk J) I)} →
{φ : hI.DPMorphism hJ} → φ.toRingHom = Ideal.Quotient.mk J → hI.SubDPIdeal | true |
NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates_apply | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
(a : ↑(NumberField.mixedEmbedding.fundamentalCone.integerSet K)),
NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates K a =
⟦NumberField.mixedEmbedding.fundamentalCone.preimageOfMemIntegerSet a⟧ | true |
Subsemigroup.gciMapComap.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {f : M →ₙ* N} (hf : Function.Injective ⇑f),
Subsemigroup.gciMapComap hf = ⋯.toGaloisCoinsertion ⋯ | true |
_private.Mathlib.Analysis.MeanInequalities.0.ENNReal.inner_le_Lp_mul_Lq._simp_1_5 | Mathlib.Analysis.MeanInequalities | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | false |
Nat.dist_eq_zero | Mathlib.Data.Nat.Dist | ∀ {n m : ℕ}, n = m → n.dist m = 0 | true |
MonoidAlgebra.comapDomain._proof_1 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {M : Type u_1} {N : Type u_2} [inst : Semiring R] (f : M → N),
Function.Injective f → ∀ (x : MonoidAlgebra R N), Set.InjOn f (f ⁻¹' ↑x.coeff.support) | false |
MeasureTheory.isProbabilityMeasure_comap | Mathlib.MeasureTheory.Measure.Typeclasses.Probability | ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {μ : MeasureTheory.Measure α}
[MeasureTheory.IsProbabilityMeasure μ] {f : β → α},
Function.Injective f →
(∀ᵐ (a : α) ∂μ, a ∈ Set.range f) →
(∀ (s : Set β), MeasurableSet s → MeasurableSet (f '' s)) →
MeasureTheory.IsProbabilityMeasure (MeasureTheory.Measure.comap f μ) | true |
Set.Ioc.instMul | Mathlib.Algebra.Order.Interval.Set.Instances | {R : Type u_1} → [inst : Semiring R] → [inst_1 : PartialOrder R] → [IsStrictOrderedRing R] → Mul ↑(Set.Ioc 0 1) | true |
Algebra.Generators.CotangentSpace.compEquiv | Mathlib.RingTheory.Kaehler.JacobiZariski | {R : Type u₁} →
{S : Type u₂} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{T : Type u₃} →
[inst_3 : CommRing T] →
[inst_4 : Algebra R T] →
[inst_5 : Algebra S T] →
[inst_6 : IsScalarTower R S T] →
{ι : Type w₁} →
{σ : Type w₂} →
(Q : Algebra.Generators S T ι) →
(P : Algebra.Generators R S σ) →
(Q.comp P).toExtension.CotangentSpace ≃ₗ[T]
Q.toExtension.CotangentSpace × TensorProduct S T P.toExtension.CotangentSpace | true |
Action.Functor.mapActionPreservesColimit_of_preserves | Mathlib.CategoryTheory.Action.Limits | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {W : Type u_3}
[inst_1 : CategoryTheory.Category.{v_2, u_3} W] (F : CategoryTheory.Functor V W) (G : Type u_4) [inst_2 : Monoid G]
{J : Type u_5} [inst_3 : CategoryTheory.Category.{v_3, u_5} J] (K : CategoryTheory.Functor J (Action V G))
[CategoryTheory.Limits.HasColimit (K.comp (Action.forget V G))]
[CategoryTheory.Limits.PreservesColimit (K.comp (Action.forget V G)) F],
CategoryTheory.Limits.PreservesColimit K (F.mapAction G) | true |
CategoryTheory.Limits.Bicone.toBinaryBiconeIsBilimit | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{X Y : C} →
(b : CategoryTheory.Limits.Bicone (CategoryTheory.Limits.pairFunction X Y)) →
b.toBinaryBicone.IsBilimit ≃ b.IsBilimit | true |
_private.Init.Grind.Offset.0.Lean.Grind.Nat.lo_ro_2._proof_1_1 | Init.Grind.Offset | ∀ (u w v k₁ k₂ : ℕ), u + k₁ ≤ w → w ≤ v + k₂ → ¬u ≤ v + (k₂ - k₁) → False | false |
List.dropSliceTR.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (n : ℕ) (l : List α), List.dropSliceTR n 0 l = l | true |
AddChar.expect_ne_zero_iff_eq_zero | Mathlib.Analysis.Fourier.FiniteAbelian.Orthogonality | ∀ {G : Type u_1} {R : Type u_3} [inst : AddGroup G] [inst_1 : Fintype G] [inst_2 : Semifield R] [IsDomain R]
[inst_4 : CharZero R] {ψ : AddChar G R}, (Finset.univ.expect fun x => ψ x) ≠ 0 ↔ ψ = 0 | true |
Matrix.isIrreducible_transpose_iff | Mathlib.LinearAlgebra.Matrix.Irreducible.Defs | ∀ {n : Type u_1} {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] {A : Matrix n n R},
A.transpose.IsIrreducible ↔ A.IsIrreducible | true |
ZeroAtInftyContinuousMap.instNonUnitalCommCStarAlgebra._proof_7 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_1} {A : Type u_2} [inst : TopologicalSpace α] [inst_1 : NonUnitalCommCStarAlgebra A]
(a b c : ZeroAtInftyContinuousMap α A), (a + b) * c = a * c + b * c | false |
_private.Lean.Meta.Constructions.SparseCasesOn.0.Lean.Meta.instBEqSparseCasesOnKey.beq | Lean.Meta.Constructions.SparseCasesOn | Lean.Meta.SparseCasesOnKey✝ → Lean.Meta.SparseCasesOnKey✝ → Bool | true |
CommSemiring.toCoalgebra | Mathlib.RingTheory.Coalgebra.Basic | (R : Type u) → [inst : CommSemiring R] → Coalgebra R R | true |
_private.Lean.Meta.Canonicalizer.0.Lean.Meta.Canonicalizer.canon.match_4 | Lean.Meta.Canonicalizer | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → (Unit → motive none) → ((a : Lean.Expr) → motive (some a)) → motive x | false |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.code.closer | Lean.DocString.Parser | ℕ → Lean.Parser.ParserFn | true |
_private.Mathlib.Order.Lattice.0.pairwise_iff_lt._simp_1_3 | Mathlib.Order.Lattice | ∀ {a b c : Prop}, (a ∨ b → c) = ((a → c) ∧ (b → c)) | false |
IsMinFilter.neg | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : AddCommGroup β] [inst_1 : PartialOrder β] [IsOrderedAddMonoid β] {f : α → β} {a : α}
{l : Filter α}, IsMinFilter f l a → IsMaxFilter (fun x => -f x) l a | true |
Lean.Elab.Term.PostponeBehavior.toCtorIdx | Lean.Elab.SyntheticMVars | Lean.Elab.Term.PostponeBehavior → ℕ | false |
AnalyticOnNhd.iteratedFDeriv | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{s : Set E} [CompleteSpace F], AnalyticOnNhd 𝕜 f s → ∀ (n : ℕ), AnalyticOnNhd 𝕜 (iteratedFDeriv 𝕜 n f) s | true |
_private.Mathlib.Order.JordanHolder.0.CompositionSeries.snoc_eraseLast_last._simp_1_1 | Mathlib.Order.JordanHolder | ∀ {n : ℕ} {a b : Fin n}, (a = b) = (↑a = ↑b) | false |
Module.Basis.repr_eq_iff' | Mathlib.LinearAlgebra.Basis.Defs | ∀ {ι : Type u_10} {R : Type u_11} {M : Type u_12} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{b : Module.Basis ι R M} {f : M ≃ₗ[R] ι →₀ R}, b.repr = f ↔ ∀ (i : ι), f (b i) = fun₀ | i => 1 | true |
_private.Lean.Server.Requests.0.Lean.Server.RequestM.waitFindSnapAux.match_1 | Lean.Server.Requests | (motive : Except IO.Error (Option Lean.Server.Snapshots.Snapshot) → Sort u_1) →
(x : Except IO.Error (Option Lean.Server.Snapshots.Snapshot)) →
((e : IO.Error) → motive (Except.error e)) →
(Unit → motive (Except.ok none)) →
((snap : Lean.Server.Snapshots.Snapshot) → motive (Except.ok (some snap))) → motive x | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.