name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SSet.Subcomplex.Pairing.RankFunction.filtration | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | {X : SSet} →
{A : X.Subcomplex} → {P : A.Pairing} → {ι : Type v} → [inst : LinearOrder ι] → P.RankFunction ι → ι → X.Subcomplex | The filtration of a simplicial set given by a rank function
for a proper pairing of a subcomplex. | true |
Algebra.TensorProduct.equivFinsuppOfBasis_apply | Mathlib.LinearAlgebra.TensorProduct.Free | ∀ {R : Type u_1} (A : Type u_2) {V : Type u_3} [inst : CommSemiring A] [inst_1 : CommSemiring R] [inst_2 : Algebra R A]
[inst_3 : AddCommGroup V] [inst_4 : Module R V] {ι : Type u_4} (b : Module.Basis ι R V) (x : TensorProduct R A V),
(Algebra.TensorProduct.equivFinsuppOfBasis A b) x =
(TensorProduct.finsuppSca... | null | true |
instBooleanRingCarrierToBddLatToBddDistLatOfAsBoolAlg._proof_22 | Mathlib.Algebra.Category.BoolRing | ∀ {R : Type u_1} [inst : BooleanRing R],
autoParam (∀ (x : ↑(↧(AsBoolAlg R)).toBddDistLat.toBddLat.toLat), x ^ 0 = 1) Monoid.npow_zero._autoParam | null | false |
NFA.Path.nil.elim | Mathlib.Computability.NFA | {α : Type u} →
{σ : Type v} →
{M : NFA α σ} →
{motive : (a a_1 : σ) → (a_2 : List α) → M.Path a a_1 a_2 → Sort u_1} →
{a a_1 : σ} →
{a_2 : List α} →
(t : M.Path a a_1 a_2) → t.ctorIdx = 0 → ((s : σ) → motive s s [] (NFA.Path.nil s)) → motive a a_1 a_2 t | null | false |
Lean.Elab.Command.InductiveViewToCoinductiveElab | Lean.Elab.MutualInductive | Lean.Elab.Command.InductiveElabStep1 → Lean.Elab.Command.CoinductiveElabData | null | true |
ZeroAtInftyContinuousMap.instSub | Mathlib.Topology.ContinuousMap.ZeroAtInfty | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
[inst_2 : AddGroup β] → [IsTopologicalAddGroup β] → Sub (ZeroAtInftyContinuousMap α β) | null | true |
Matroid.comap_map | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {M : Matroid α} {f : α → β} (hf : Function.Injective f), (M.map f ⋯).comap f = M | null | true |
Real.limsSup_of_not_isCobounded | Mathlib.Order.Filter.ENNReal | ∀ {f : Filter ℝ}, ¬Filter.IsCobounded (fun x1 x2 => x1 ≤ x2) f → f.limsSup = 0 | null | true |
NonUnitalStarSubalgebra.toNonUnitalRing | Mathlib.Algebra.Star.NonUnitalSubalgebra | {R : Type u_1} →
{A : Type u_2} →
[inst : CommRing R] →
[inst_1 : NonUnitalRing A] →
[inst_2 : Module R A] → [inst_3 : Star A] → (S : NonUnitalStarSubalgebra R A) → NonUnitalRing ↥S | null | true |
Localization.Away.mulEquivOfQuotient.eq_1 | Mathlib.GroupTheory.MonoidLocalization.Away | ∀ {M : Type u_1} [inst : CommMonoid M] {N : Type u_2} [inst_1 : CommMonoid N] (x : M)
(f : Submonoid.LocalizationMap.AwayMap x N),
Localization.Away.mulEquivOfQuotient x f = Localization.mulEquivOfQuotient f | null | true |
CategoryTheory.ConnectedComponents.typeToCatHomEquiv._proof_2 | Mathlib.CategoryTheory.ConnectedComponents | ∀ (J : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} J] (X : Type u_3)
(f : CategoryTheory.ConnectedComponents J → X),
CategoryTheory.ConnectedComponents.liftFunctor J (CategoryTheory.ConnectedComponents.functorToDiscrete X f) = f | null | false |
isClosed_setOf_lipschitzWith | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {α : Type u_4} {β : Type u_5} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (K : NNReal),
IsClosed {f | LipschitzWith K f} | **Alias** of `isClosed_setOfPred_lipschitzWith`. | true |
Measurable.const_inf | Mathlib.MeasureTheory.Order.Lattice | ∀ {M : Type u_1} [inst : MeasurableSpace M] {α : Type u_2} {m : MeasurableSpace α} {f : α → M} [inst_1 : Min M]
[MeasurableInf M], Measurable f → ∀ (c : M), Measurable fun x => c ⊓ f x | null | true |
Vector.getElem_eq_getElem?_get._proof_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ}, i < n → xs[i]?.isSome = true | null | false |
_private.Lake.Util.Version.0.Lake.ToolchainVer.ofString.match_1 | Lake.Util.Version | (motive : Except String Lake.StdVer → Sort u_1) →
(x : Except String Lake.StdVer) →
((ver : Lake.StdVer) → motive (Except.ok ver)) → ((x : Except String Lake.StdVer) → motive x) → motive x | null | false |
CategoryTheory.ShortComplex.RightHomologyData.op._proof_2 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C}, CategoryTheory.CategoryStruct.comp S.op.f S.op.g = 0 | null | false |
CategoryTheory.AddGrp.forget₂AddMon_comp_forget | Mathlib.CategoryTheory.Monoidal.Grp | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C],
(CategoryTheory.AddGrp.forget₂Mon C).comp (CategoryTheory.AddMon.forget C) = CategoryTheory.AddGrp.forget C | null | true |
PadicInt.mahlerSeries.congr_simp | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : Module ℤ_[p] E]
[inst_2 : IsBoundedSMul ℤ_[p] E] (a a_1 : ℕ → E), a = a_1 → PadicInt.mahlerSeries a = PadicInt.mahlerSeries a_1 | null | true |
Lean.Meta.Try.Collector.Context.mk | Lean.Meta.Tactic.Try.Collect | Lean.Try.Config → Lean.Meta.Try.Collector.Context | null | true |
Lean.IR.EmitLLVM.Context.mk.inj | Lean.Compiler.IR.EmitLLVM | ∀ {llvmctx : Lean.LLVM.Context} {env : Lean.Environment} {modName : Lean.Name} {jpMap : Lean.IR.JPParamsMap}
{mainFn : Lean.IR.FunId} {mainParams : Array Lean.IR.Param} {llvmmodule : Lean.LLVM.Module llvmctx}
{env_1 : Lean.Environment} {modName_1 : Lean.Name} {jpMap_1 : Lean.IR.JPParamsMap} {mainFn_1 : Lean.IR.FunI... | null | true |
DedekindCut.upperBounds_left | Mathlib.Order.Completion | ∀ {α : Type u_1} [inst : Preorder α] (A : DedekindCut α), upperBounds A.left = A.right | null | true |
CategoryTheory.MorphismProperty.Over.pullback._proof_5 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (P Q : CategoryTheory.MorphismProperty T)
[inst_1 : Q.IsMultiplicative] {X Y : T} (f : X ⟶ Y) [inst_2 : P.HasPullbacksAlong f] {A B : P.Over Q Y} (g : A ⟶ B),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (CategoryTheory.L... | null | false |
LinearMap.BilinForm.SeparatingRight.toMatrix' | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₂ : Type u_3} [inst : CommRing R₂] {ι : Type u_6} [inst_1 : DecidableEq ι] [inst_2 : Fintype ι]
{B : LinearMap.BilinForm R₂ (ι → R₂)}, LinearMap.SeparatingRight B → (LinearMap.BilinForm.toMatrix' B).SeparatingRight | null | true |
IsDiffImmersionAt.comp | Mathlib.Geometry.Manifold.ImmersionDiff | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} {F : Type u_3} {E' : Type u}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E']
[inst_4 : NormedSpace 𝕜 E'] [inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F] {H : Type u_6}
[inst_7 : Topologic... | If `f` is an immersion at `x`, and `g` is an immersion at `f x` (both in the sense of
differentials), then `g ∘ f` is an immersion at `x`. | true |
Finset.map_ssubset_map | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s t : Finset α}, Finset.map f s ⊂ Finset.map f t ↔ s ⊂ t | null | true |
AlgebraicGeometry.Scheme.AffineEtale.Spec | Mathlib.AlgebraicGeometry.Sites.AffineEtale | (S : AlgebraicGeometry.Scheme) → CategoryTheory.Functor S.AffineEtale S.Etale | The `Spec` functor from the small affine étale site of `S` to the small étale site of `S`. | true |
_private.Lean.Server.FileWorker.SignatureHelp.0.Lean.Server.FileWorker.SignatureHelp.findSignatureHelp?.match_5 | Lean.Server.FileWorker.SignatureHelp | (motive : Lean.Server.FileWorker.SignatureHelp.SearchControl → Sort u_1) →
(control : Lean.Server.FileWorker.SignatureHelp.SearchControl) →
(Unit → motive Lean.Server.FileWorker.SignatureHelp.SearchControl.stop) →
((x : Lean.Server.FileWorker.SignatureHelp.SearchControl) → motive x) → motive control | null | false |
Matrix.SpecialLinearGroup.transvection_mulVec_single_other | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {ι : Type u_1} {F : Type u_2} [inst : DecidableEq ι] [inst_1 : Fintype ι] [inst_2 : CommRing F] {i j : ι}
(hij : i ≠ j) (b : F),
(↑(Matrix.SpecialLinearGroup.transvection hij b)).mulVec (Pi.single j 1) = Pi.single j 1 + b • Pi.single i 1 | null | true |
Filter.frequently_lt_of_lt_limsup | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLinearOrder β] {f : Filter α} {u : α → β} {b : β},
autoParam (Filter.IsCoboundedUnder (fun x1 x2 => x1 ≤ x2) f u) Filter.frequently_lt_of_lt_limsup._auto_1 →
b < Filter.limsup u f → ∃ᶠ (x : α) in f, b < u x | null | true |
_private.Lean.AddDecl.0.Lean.registerNamePrefixes.match_1 | Lean.AddDecl | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) → ((p : Lean.Name) → (str : String) → motive (p.str str)) → ((x : Lean.Name) → motive x) → motive x | null | false |
antisymmetrization_fibration | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} [inst : Preorder α],
Relation.Fibration (fun x1 x2 => x1 < x2) (fun x1 x2 => x1 < x2) (toAntisymmetrization fun x1 x2 => x1 ≤ x2) | null | true |
OrderedFinpartition.compAlongOrderedFinpartitionₗ._proof_2 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_4} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_2}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ} (c : OrderedFinpartition n)
... | null | false |
MLList.foldsM | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} → {β α : Type u_1} → [Monad m] → (β → α → m β) → β → MLList m α → MLList m β | Gives the monadic lazy list consisting all of folds of a function on a given initial element.
Thus `[a₀, a₁, ...].foldsM f b` will give `[b, ← f b a₀, ← f (← f b a₀) a₁, ...]`. | true |
Finset.card_pow_le | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Monoid α] {s : Finset α} {n : ℕ}, (s ^ n).card ≤ s.card ^ n | null | true |
CategoryTheory.Presieve.isSheafFor_singleton | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X Y : C}
{f : X ⟶ Y},
CategoryTheory.Presieve.IsSheafFor P (CategoryTheory.Presieve.singleton f) ↔
∀ (x : P.obj (Opposite.op X)),
(∀ {Z : C} (p₁ p₂ : Z ⟶ X),
CategoryTheory.CategoryStruct.comp ... | null | true |
isClosed_preCantorSet | Mathlib.Topology.Instances.CantorSet | ∀ (n : ℕ), IsClosed (preCantorSet n) | The preCantor sets are closed. | true |
CategoryTheory.Limits.Types.instHasPushoutsType | Mathlib.CategoryTheory.Limits.Types.Pushouts | CategoryTheory.Limits.HasPushouts (Type u) | null | true |
CochainComplex.mappingCocone.inr_v_desc_f | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {M : CochainComplex C ℤ}
(α : CochainComplex.HomComplex.Cochain K M 0) (β : CochainComplex.HomComplex.Cocycle L M 1)
(hαβ... | null | true |
MulAction.rec | Mathlib.Algebra.Group.Action.Defs | {α : Type u_9} →
{β : Type u_10} →
[inst : Monoid α] →
{motive : MulAction α β → Sort u} →
([toSemigroupAction : SemigroupAction α β] →
(one_smul : ∀ (b : β), 1 • b = b) →
motive { toSemigroupAction := toSemigroupAction, one_smul := one_smul }) →
(t : MulAction α ... | null | false |
Topology.IsUpperSet.monotone_iff_continuous | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : TopologicalSpace α]
[inst_3 : TopologicalSpace β] [Topology.IsUpperSet α] [Topology.IsUpperSet β] {f : α → β}, Monotone f ↔ Continuous f | null | true |
EquivLike.range_eq_univ | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} [inst : EquivLike E α β] (e : E), Set.range ⇑e = Set.univ | null | true |
Submodule.IsMinimalPrimaryDecomposition.primary | Mathlib.RingTheory.Lasker | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N : Submodule R M} {t : Finset (Submodule R M)},
N.IsMinimalPrimaryDecomposition t → ∀ ⦃J : Submodule R M⦄, J ∈ t → J.IsPrimary | null | true |
instRightCancelMonoidSubtypeMemSubmonoidNonZeroDivisorsOfIsRightCancelMulZero._proof_1 | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] (z x x_1 : ↥(nonZeroDivisors M₀)),
(fun x => x * z) x = (fun x => x * z) x_1 → ↑x * ↑z = ↑x_1 * ↑z | null | false |
SemiNormedGrp₁.str | Mathlib.Analysis.Normed.Group.SemiNormedGrp | (self : SemiNormedGrp₁) → SeminormedAddCommGroup self.carrier | null | true |
PartitionOfUnity.instFunLikeContinuousMapReal | Mathlib.Topology.PartitionOfUnity | {ι : Type u} → {X : Type v} → [inst : TopologicalSpace X] → {s : Set X} → FunLike (PartitionOfUnity ι X s) ι C(X, ℝ) | null | true |
_private.Mathlib.Tactic.ExtractGoal.0.Mathlib.Tactic.ExtractGoal.goalSignature.match_3 | Mathlib.Tactic.ExtractGoal | (motive : Lean.NameSet × Lean.Elab.Command.State → Sort u_1) →
(x : Lean.NameSet × Lean.Elab.Command.State) →
((ts : Lean.NameSet) → (snd : Lean.Elab.Command.State) → motive (ts, snd)) → motive x | null | false |
AddSubgroup.addSubgroupOfEquivOfLe_symm_apply_coe_coe | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_6} [inst : AddGroup G] {H K : AddSubgroup G} (h : H ≤ K) (g : ↥H),
↑↑((AddSubgroup.addSubgroupOfEquivOfLe h).symm g) = ↑g | null | true |
and_not_self._simp_1 | Init.SimpLemmas | ∀ {a : Prop}, (a ∧ ¬a) = False | null | false |
Aesop.ClusterState.AddM.Context | Aesop.Forward.State | Type | Context for the `AddM` monad. | true |
AlternatingMap.continuous_of_bound | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u} {E : Type wE} {F : Type wF} {ι : Type v} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 F] [inst_5 : Fintype ι] (f : E [⋀^ι]→ₗ[𝕜] F) (C : ℝ),
(∀ (m : ι → E), ‖f m‖ ≤ C * ∏ i, ‖m i‖) →... | If an alternating map satisfies an inequality `‖f m‖ ≤ C * ∏ i, ‖m i‖`,
then it is continuous. | true |
AddMonoid.Coprod.snd_comp_swap | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : AddMonoid M] [inst_1 : AddMonoid N],
AddMonoid.Coprod.snd.comp (AddMonoid.Coprod.swap M N) = AddMonoid.Coprod.fst | null | true |
IsLocalRing.spanFinrank_eq_finrank_quotient | Mathlib.Algebra.Module.SpanRankOperations | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_3} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsLocalRing R] (N : Submodule R M),
N.FG → N.spanFinrank = Module.finrank (R ⧸ IsLocalRing.maximalIdeal R) (↥N ⧸ IsLocalRing.maximalIdeal R • ⊤) | null | true |
Lean.Elab.Tactic.evalChoiceAux._unsafe_rec | Lean.Elab.Tactic.BuiltinTactic | Array Lean.Syntax → ℕ → Lean.Elab.Tactic.TacticM Unit | null | false |
Std.HashSet.Raw.union | Std.Data.HashSet.Raw | {α : Type u} → [BEq α] → [Hashable α] → Std.HashSet.Raw α → Std.HashSet.Raw α → Std.HashSet.Raw α | Computes the union of the given hash sets.
This function always merges the smaller set into the larger set, so the expected runtime is
`O(min(m₁.size, m₂.size))`.
| true |
CStarAlgebra.norm_le_iff_le_algebraMap._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax | null | false |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.MethodsRefPointed | Lean.Meta.Tactic.Simp.Types | NonemptyType | null | true |
DihedralGroup.instIsKleinFourOfNatNat | Mathlib.GroupTheory.SpecificGroups.Dihedral | IsKleinFour (DihedralGroup 2) | null | true |
Nat.Primes.prodNatEquiv._proof_4 | Mathlib.Data.Nat.Factorization.PrimePow | ∀ (n : { n // IsPrimePow n }),
(fun pk => ⟨↑pk.1 ^ (pk.2 + 1), ⋯⟩) ((fun n => (⟨(↑n).minFac, ⋯⟩, (↑n).factorization (↑n).minFac - 1)) n) = n | null | false |
_private.Mathlib.Data.Finsupp.BigOperators.0.List.mem_foldr_sup_support_iff._simp_1_1 | Mathlib.Data.Finsupp.BigOperators | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M} {a : α}, (a ∈ f.support) = (f a ≠ 0) | null | false |
MeasureTheory.IsFundamentalDomain.measure_set_eq | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α] {s t : Set α}
{μ : MeasureTheory.Measure α} [MeasurableConstSMul G α] [MeasureTheory.SMulInvariantMeasure G α μ] [Countable G],
MeasureTheory.IsFundamentalDomain G s μ →
MeasureTheory.IsFundamentalDomain G t μ... | null | true |
List.rdropWhile_last_not | Mathlib.Data.List.DropRight | ∀ {α : Type u_1} (p : α → Bool) (l : List α) (hl : List.rdropWhile p l ≠ []),
¬p ((List.rdropWhile p l).getLast hl) = true | null | true |
Metric.unitClosedBall.instMonoid._aux_1 | Mathlib.Analysis.Normed.Field.UnitBall | {𝕜 : Type u_1} → [inst : SeminormedRing 𝕜] → [NormOneClass 𝕜] → ↑(Metric.closedBall 0 1) | null | false |
_private.Lean.LocalContext.0.Lean.LocalDecl.hasValue.match_1 | Lean.LocalContext | (motive : Lean.LocalDecl → Bool → Sort u_1) →
(x : Lean.LocalDecl) →
(x_1 : Bool) →
((index : ℕ) →
(fvarId : Lean.FVarId) →
(userName : Lean.Name) →
(type : Lean.Expr) →
(bi : Lean.BinderInfo) →
(kind : Lean.LocalDeclKind) →
... | null | false |
CochainComplex.mappingCone.lift_f_fst_v_assoc | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {K : CochainComplex C ℤ}
(α : CochainComplex.HomComplex.Cocycle K F 1) (β : CochainComplex.HomComplex.Cochain K G 0)
(eq : ... | null | true |
Int16.ofInt_int8ToInt | Init.Data.SInt.Lemmas | ∀ (x : Int8), Int16.ofInt x.toInt = x.toInt16 | null | true |
_private.Mathlib.CategoryTheory.Monoidal.NaturalTransformation.0.CategoryTheory.Adjunction.Equivalence.instIsMonoidalCounit._proof_1 | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(e : C ≌ D) [inst_4 : e.functor.Monoidal] [inst_5 : e.inverse.Monoidal] [e.IsMonoidal],
CategoryTh... | null | false |
Algebra.TensorProduct.tensorQuotientEquiv | Mathlib.RingTheory.TensorProduct.Quotient | {R : Type u_1} →
(S : Type u_2) →
(T : Type u_3) →
(A : Type u_4) →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
[inst_3 : CommRing T] →
[inst_4 : Algebra R T] →
[inst_5 : CommRing A] →
... | The tensor product of an `S`-algebra `A` over `R` with the quotient of `T` by an ideal `I`
is isomorphic (as an `S`-algebra) to the quotient of `A ⊗[R] T` by the extended ideal. | true |
Std.DTreeMap.Internal.Impl.Const.getEntryLE.congr_simp | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] (k k_1 : α) (e_k : k = k_1)
(t t_1 : Std.DTreeMap.Internal.Impl α fun x => β) (e_t : t = t_1) (ho : t.Ordered)
(he : ∃ a ∈ t, (compare a k).isLE = true),
Std.DTreeMap.Internal.Impl.Const.getEntryLE k t ho he = Std.DTreeMap.Internal.Impl.Const.ge... | null | true |
FirstOrder.Language.Hom.range_eq_top | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N] {f : L.Hom M N},
f.range = ⊤ ↔ Function.Surjective ⇑f | null | true |
Multiset.stronglyMeasurable_sum | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M] [ContinuousAdd M]
{m : MeasurableSpace α} (l : Multiset (α → M)),
(∀ f ∈ l, MeasureTheory.StronglyMeasurable f) → MeasureTheory.StronglyMeasurable l.sum | null | true |
MeasureTheory.Measure.measure_isAddHaarMeasure_eq_smul_of_isOpen | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [LocallyCompactSpace G] (μ' μ : MeasureTheory.Measure G)
[inst_6 : μ.IsAddHaarMeasure] [inst_7 : μ'.IsAddHaarMeasure] {s : Set G},
IsOpen s → μ' s = μ'.addHaar... | **Uniqueness of Haar measures**:
Given two additive Haar measures, they coincide in the following sense: they give the same value to
open sets, up to the multiplicative constant `addHaarScalarFactor μ' μ`. | true |
_private.Mathlib.LinearAlgebra.Projectivization.PSL.Stabilizer.0.LinearMap.exists_restrict_span_singleton_eq_smul_id._simp_1_3 | Mathlib.LinearAlgebra.Projectivization.PSL.Stabilizer | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
{x : M} {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R₂ M₂}, (x ∈ Submodule.comap f p) = (f x ∈ p) | null | false |
AlgebraicGeometry.Scheme.Cover.mem_pretopology | Mathlib.AlgebraicGeometry.Sites.Pretopology | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [inst : P.IsStableUnderBaseChange]
[inst_1 : P.IsMultiplicative] {X : AlgebraicGeometry.Scheme}
{𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X},
CategoryTheory.Presieve.ofArrows 𝒰.X 𝒰.f ∈ (AlgebraicGeometry.Scheme.... | null | true |
CategoryTheory.Limits.initialUnopOfTerminal._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : Cᵒᵖ} (t : CategoryTheory.Limits.IsTerminal X)
(x : CategoryTheory.Limits.Cocone (CategoryTheory.Functor.empty C))
(x_1 : (CategoryTheory.Limits.asEmptyCocone (Opposite.unop X)).pt ⟶ x.pt),
(∀ (j : CategoryTheory.Discrete PEmpty.{1}),
Catego... | null | false |
CategoryTheory.IsPullback.exact_shortComplex' | Mathlib.CategoryTheory.Abelian.CommSq | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X₁ X₂ X₃ X₄ : C}
{t : X₁ ⟶ X₂} {l : X₁ ⟶ X₃} {r : X₂ ⟶ X₄} {b : X₃ ⟶ X₄} (h : CategoryTheory.IsPullback t l r b), ⋯.shortComplex'.Exact | null | true |
CategoryTheory.IsConnected.of_constant_of_preserves_morphisms | Mathlib.CategoryTheory.IsConnected | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] [Nonempty J],
(∀ {α : Type u₁} (F : J → α), (∀ {j₁ j₂ : J} (x : j₁ ⟶ j₂), F j₁ = F j₂) → ∀ (j j' : J), F j = F j') →
CategoryTheory.IsConnected J | `J` is connected if: given any function `F : J → α` which is constant for any
`j₁, j₂` for which there is a morphism `j₁ ⟶ j₂`, then `F` is constant.
This can be thought of as a local-to-global property.
The converse of `constant_of_preserves_morphisms`.
| true |
Real.integrable_sinc | Mathlib.MeasureTheory.Function.SpecialFunctions.Sinc | ∀ {μ : MeasureTheory.Measure ℝ} [MeasureTheory.IsFiniteMeasure μ], MeasureTheory.Integrable Real.sinc μ | null | true |
AlgebraicGeometry.Scheme.Opens.ι | Mathlib.AlgebraicGeometry.Restrict | {X : AlgebraicGeometry.Scheme} → (U : X.Opens) → ↑U ⟶ X | The restriction of a scheme to an open subset. | true |
_private.Mathlib.Topology.Sets.Closeds.0.TopologicalSpace.Closeds.isAtom_iff._simp_1_1 | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_2} [inst : TopologicalSpace α] [T1Space α] {s : TopologicalSpace.Closeds α}, IsAtom s = IsAtom ↑s | null | false |
Nat.isAlmostPrime_zero_iff | Mathlib.NumberTheory.AlmostPrime | ∀ {n : ℕ}, Nat.IsAlmostPrime 0 n ↔ n = 1 | null | true |
CauchyFilter.mem_uniformity' | Mathlib.Topology.UniformSpace.Completion | ∀ {α : Type u} [inst : UniformSpace α] {s : Set (CauchyFilter α × CauchyFilter α)},
s ∈ uniformity (CauchyFilter α) ↔ ∃ t ∈ uniformity α, ∀ (f g : CauchyFilter α), t ∈ ↑f ×ˢ ↑g → (f, g) ∈ s | null | true |
Lean.Meta.RefinedDiscrTree.format | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | {α : Type} → [Std.ToFormat α] → Lean.Meta.RefinedDiscrTree α → Std.Format | Format a `RefinedDiscrTree` as a flowchart.
- Non-terminal nodes are of the form `{key} =>`, followed by all of the following nodes,
indented with 2 more spaces.
- Terminal nodes have either "entries", containing the return values,
or "pending entries", for nodes that have not been evaluated/expanded.
For example:... | true |
LieModuleHom.toLinearMap | Mathlib.Algebra.Lie.Basic | {R : Type u} →
{L : Type v} →
{M : Type w} →
{N : Type w₁} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
... | null | true |
_private.Mathlib.RepresentationTheory.Homological.GroupCohomology.Shapiro.0.groupCohomology.linearYonedaObjResProjectiveResolutionIso._simp_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Shapiro | ∀ {R : Type u} [inst : Ring R] {M N O : Type v} [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : AddCommGroup O] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R O] (f : M →ₗ[R] N)
(g : N →ₗ[R] O), CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom f) (ModuleCat.ofHom g) = ModuleCat.ofHo... | null | false |
Real.instAddMonoid | Mathlib.Basic.Real.Basic | AddMonoid ℝ | null | true |
_private.Init.Data.Range.Polymorphic.Char.0.Char.instPreservesLEFinNumCodePointsMap | Init.Data.Range.Polymorphic.Char | Char.map✝.PreservesLE | null | true |
Algebra.trace.eq_1 | Mathlib.RingTheory.Trace.Defs | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
Algebra.trace R S = LinearMap.trace R S ∘ₗ (Algebra.lmul R S).toLinearMap | null | true |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.coreOfNat.elim | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_7 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof) →
t.ctorIdx = 1 →
((e thm : Lean.Expr) →
(d : ℕ) →
(a : Int.Internal.Linear.Expr) →
motive_7 (Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.coreOfNat e thm d a... | null | false |
_private.Mathlib.RingTheory.Adjoin.FG.0.Subalgebra.FG.map.match_1_1 | Mathlib.RingTheory.Adjoin.FG | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
{S : Subalgebra R A} (motive : S.FG → Prop) (hs : S.FG),
(∀ (s : Finset A) (hs : Algebra.adjoin R ↑s = S), motive ⋯) → motive hs | null | false |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.SynthInstance.tryAnswer.match_1 | Lean.Meta.SynthInstance | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(x : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((fst : Array Lean.Expr) → (fst_1 : Array Lean.BinderInfo) → (val : Lean.Expr) → motive (fst, fst_1, val)) →
motive x | null | false |
Polynomial.cardPowDegree_isEuclidean | Mathlib.Algebra.Polynomial.Degree.CardPowDegree | ∀ {Fq : Type u_1} [inst : Field Fq] [inst_1 : Fintype Fq], Polynomial.cardPowDegree.IsEuclidean | null | true |
_private.Init.Data.Nat.Lemmas.0.Nat.exists_eq_add_one.match_1_1 | Init.Data.Nat.Lemmas | ∀ {a : ℕ} (motive : (∃ n, a = n + 1) → Prop) (x : ∃ n, a = n + 1), (∀ (n : ℕ) (h : a = n + 1), motive ⋯) → motive x | null | false |
NNReal.sqrt_eq_one._simp_1 | Mathlib.Analysis.Real.Sqrt | ∀ {x : NNReal}, (NNReal.sqrt x = 1) = (x = 1) | null | false |
List.IsChain.count_not_le_count_add_one | Mathlib.Data.Bool.Count | ∀ {l : List Bool}, List.IsChain (fun x1 x2 => x1 ≠ x2) l → ∀ (b : Bool), List.count (!b) l ≤ List.count b l + 1 | null | true |
CategoryTheory.MonoidalClosed.whiskerLeft_curry'_ihom_ev_app_assoc | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
[inst_2 : CategoryTheory.Closed X] (f : X ⟶ Y) {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.MonoidalClosed.curry' f))
... | null | true |
CategoryTheory.Pseudofunctor.Grothendieck.category._proof_3 | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} 𝒮]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} {a b : F.Grothendieck}
(f : a ⟶ b), CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) f = f | null | false |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBNode.mem_insert._simp_1_7 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {x : α} {t : RBTree.RBNode α}, (x ∈ t) = (x ∈ t.toList) | null | false |
Finset.weightedVSubVSubWeights_apply_left | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ (k : Type u_1) [inst : Ring k] {ι : Type u_4} [inst_1 : DecidableEq ι] {i j : ι},
i ≠ j → Finset.weightedVSubVSubWeights k i j i = 1 | null | true |
Lean.Elab.Structural.RecArgCandidate.comb | Lean.Elab.PreDefinition.Structural.FindRecArg | Lean.Elab.Structural.RecArgCandidate → Array Lean.Elab.Structural.RecArgInfo | null | true |
CategoryTheory.ComposableArrows.isoMkSucc._proof_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C (n + 1)}
(α : F.obj' 0 ⋯ ≅ G.obj' 0 ⋯) (β : F.δ₀ ≅ G.δ₀),
CategoryTheory.CategoryStruct.comp (F.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯)
(CategoryTheory.ComposableArrows.app' β.... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.