name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.injectiveResolutions._proof_3 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | IsRightCancelAdd ℕ | null | false |
Finset.powersetCard_mono | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} {n : ℕ} {s t : Finset α}, s ⊆ t → Finset.powersetCard n s ⊆ Finset.powersetCard n t | null | true |
groupHomology.comp_d₂₁_eq | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G),
CategoryTheory.CategoryStruct.comp (groupHomology.chainsIso₂ A).hom (groupHomology.d₂₁ A) =
CategoryTheory.CategoryStruct.comp ((groupHomology.inhomogeneousChains A).d 2 1) (groupHomology.chainsIso₁ A).hom | Let `C(G, A)` denote the complex of inhomogeneous chains of `A : Rep k G`. This lemma
says `d₂₁` gives a simpler expression for the 1st differential: that is, the following
square commutes:
```
C₂(G, A) --d 2 1--> C₁(G, A)
| |
| |
| |
v ... | true |
Subfield.inf_relfinrank_left | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] (A B : Subfield E), (A ⊓ B).relfinrank A = B.relfinrank A | null | true |
CategoryTheory.Precoverage.ZeroHypercover.Small.Index | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.Precoverage C} → {S : C} → (E : J.ZeroHypercover S) → [E.Small] → Type w' | The `w'`-index type of a `w'`-small `0`-hypercover. | true |
_private.Mathlib.Analysis.Normed.Ring.Units.0.NormedRing.inverse_add_norm._simp_1_2 | Mathlib.Analysis.Normed.Ring.Units | ∀ {α : Type u} [inst : Mul α] [inst_1 : HasDistribNeg α] (a b : α), -(a * b) = -a * b | null | false |
Int.mul.eq_2 | Init.Data.Int.Order | ∀ (m_2 n_2 : ℕ), (Int.ofNat m_2).mul (Int.negSucc n_2) = Int.negOfNat (m_2 * n_2.succ) | null | true |
Filter.Germ.map_const | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (l : Filter α) (a : β) (f : β → γ), Filter.Germ.map f ↑a = ↑(f a) | null | true |
CategoryTheory.Limits.pullbackConeOfLeftIso_π_app_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.IsIso f],
(CategoryTheory.Limits.pullbackConeOfLeftIso f g).π.app CategoryTheory.Limits.WalkingCospan.left =
CategoryTheory.CategoryStruct.comp g (CategoryTheory.inv f) | null | true |
CategoryTheory.Bicategory.InducedBicategory.Hom₂._sizeOf_1 | Mathlib.CategoryTheory.Bicategory.InducedBicategory | {B : Type u_1} →
{C : Type u_2} →
{inst : CategoryTheory.Bicategory C} →
{F : B → C} →
{X Y : CategoryTheory.Bicategory.InducedBicategory C F} →
{f g : X ⟶ Y} → [SizeOf B] → [SizeOf C] → CategoryTheory.Bicategory.InducedBicategory.Hom₂ f g → ℕ | null | false |
Finsupp.mem_rangeSingleton_apply_iff | Mathlib.Data.Finsupp.Interval | ∀ {ι : Type u_1} {α : Type u_2} [inst : Zero α] {f : ι →₀ α} {i : ι} {a : α}, a ∈ f.rangeSingleton i ↔ a = f i | null | true |
SSet.anodyneExtensions.whiskerLeft | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PushoutProduct | ∀ {X Y : SSet} {f : X ⟶ Y},
SSet.anodyneExtensions f →
∀ (Z : SSet), SSet.anodyneExtensions (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z f) | null | true |
Lean.Elab.Term.MVarErrorInfo.noConfusionType | Lean.Elab.Term.TermElabM | Sort u → Lean.Elab.Term.MVarErrorInfo → Lean.Elab.Term.MVarErrorInfo → Sort u | null | false |
WeierstrassCurve.Projective.eval_polynomial_of_Z_ne_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Projective F} {P : Fin 3 → F},
P 2 ≠ 0 →
(MvPolynomial.eval P) W.polynomial / P 2 ^ 3 = Polynomial.evalEval (P 0 / P 2) (P 1 / P 2) W.toAffine.polynomial | null | true |
Matroid.contract_eq_contract_iff | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} {M : Matroid α} {C₁ C₂ : Set α}, M.contract C₁ = M.contract C₂ ↔ C₁ ∩ M.E = C₂ ∩ M.E | null | true |
_private.Mathlib.MeasureTheory.Measure.SeparableMeasure.0.MeasureTheory.Lp.SecondCountableTopology._abel_5 | Mathlib.MeasureTheory.Measure.SeparableMeasure | ∀ {X : Type u_1} {E : Type u_2} [m : MeasurableSpace X] [inst : NormedAddCommGroup E] {μ : MeasureTheory.Measure X}
{p : ENNReal} ⦃f g : X → E⦄ (hf : MeasureTheory.MemLp f p μ) (hg : MeasureTheory.MemLp g p μ)
(bf bg : ↥(MeasureTheory.Lp E p μ)),
MeasureTheory.MemLp.toLp f hf + MeasureTheory.MemLp.toLp g hg - (bf... | null | false |
Submodule.starProjection_apply | Mathlib.Analysis.InnerProductSpace.Projection.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(U : Submodule 𝕜 E) [inst_3 : U.HasOrthogonalProjection] (v : E), U.starProjection v = ↑(U.orthogonalProjectionOnto v) | null | true |
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.mk | Mathlib.AlgebraicTopology.ExtraDegeneracy | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X : CategoryTheory.SimplicialObject.Augmented C} →
(s' : X.right ⟶ X.left.obj (Opposite.op { len := 0 })) →
(s : (n : ℕ) → X.left.obj (Opposite.op { len := n }) ⟶ X.left.obj (Opposite.op { len := n + 1 })) →
autoParam
... | null | true |
CategoryTheory.ShortComplex.SnakeInput.composableArrowsFunctor_map | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{X Y : CategoryTheory.ShortComplex.SnakeInput C} (f : X ⟶ Y),
CategoryTheory.ShortComplex.SnakeInput.composableArrowsFunctor.map f =
CategoryTheory.ComposableArrows.homMk₅ f.f₀.τ₁ f.f₀.τ₂ f.f₀.τ₃ f.f₃.τ₁ f.f₃.τ₂ f... | null | true |
Stream'.WSeq.map | Mathlib.Data.WSeq.Basic | {α : Type u} → {β : Type v} → (α → β) → Stream'.WSeq α → Stream'.WSeq β | Map a function over a weak sequence | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.incCount | Lean.Meta.LetToHave | Lean.Meta.LetToHave.M✝ Unit | Increments the count of the number of `let`s transformed into `have`s. | true |
CategoryTheory.Functor.const.opObjUnop._proof_1 | Mathlib.CategoryTheory.Functor.Const | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] (X : Cᵒᵖ) ⦃X_1 Y : Jᵒᵖ⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const Jᵒᵖ).obj (Opposite.unop X)).map f)
(CategoryTheory.CategoryStruct.id (((Catego... | null | false |
Lean.Meta.InductionSubgoal._sizeOf_1 | Lean.Meta.Tactic.Induction | Lean.Meta.InductionSubgoal → ℕ | null | false |
Finsupp.induction | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddZeroClass M] {motive : (ι →₀ M) → Prop} (f : ι →₀ M),
motive 0 →
(∀ (a : ι) (b : M) (f : ι →₀ M), a ∉ f.support → b ≠ 0 → motive f → motive ((fun₀ | a => b) + f)) → motive f | null | true |
TopologicalSpace.OpenNhdsOf.comap | Mathlib.Topology.Sets.Opens | {α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
(f : C(α, β)) → (x : α) → LatticeHom (TopologicalSpace.OpenNhdsOf (f x)) (TopologicalSpace.OpenNhdsOf x) | Preimage of an open neighborhood of `f x` under a continuous map `f` as a `LatticeHom`. | true |
Subarray.mkSlice_roc_eq_mkSlice_roo | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {lo hi : ℕ},
(Std.Roc.Sliceable.mkSlice xs lo<...=hi) = Std.Roo.Sliceable.mkSlice xs lo<...hi + 1 | null | true |
TopCat.forget_preservesColimitsOfSize | Mathlib.Topology.Category.TopCat.Limits.Basic | CategoryTheory.Limits.PreservesColimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget TopCat) | null | true |
CategoryTheory.CommGrp.instFullGrpForget₂Grp | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C], (CategoryTheory.CommGrp.forget₂Grp C).Full | null | true |
Ideal.isMaximal_of_isIntegral_of_isMaximal_comap | Mathlib.RingTheory.Ideal.GoingUp | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Algebra.IsIntegral R S] (I : Ideal S) [I.IsPrime], (Ideal.comap (algebraMap R S) I).IsMaximal → I.IsMaximal | null | true |
SubMulAction.orbitRel_of_subMul | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : Group R] [inst_1 : MulAction R M] (p : SubMulAction R M),
MulAction.orbitRel R ↥p = Setoid.comap Subtype.val (MulAction.orbitRel R M) | null | true |
ZNum.addMonoidWithOne | Mathlib.Data.Num.ZNum | AddMonoidWithOne ZNum | null | true |
HasDerivWithinAt.comp_hasDerivAt_of_eq | Mathlib.Analysis.Calculus.Deriv.Comp | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (x : 𝕜) {𝕜' : Type u_1} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {h : 𝕜 → 𝕜'} {h₂ : 𝕜' → 𝕜'} {h' h₂' y : 𝕜'} {t : Set 𝕜'},
HasDerivWithinAt h₂ h₂' t y →
HasDerivAt h h' x → (∀ᶠ (x' : 𝕜) in nhds x, h x' ∈ t) → y = h x → Ha... | null | true |
Int.le_add_of_neg_le_sub_left | Init.Data.Int.Order | ∀ {a b c : ℤ}, -a ≤ b - c → c ≤ a + b | null | true |
InnerProductSpace.ringOfCoalgebra._proof_17 | Mathlib.Analysis.InnerProductSpace.Coalgebra | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] [inst_4 : Coalgebra 𝕜 E] (n : ℕ), (n + 1).unaryCast = n.unaryCast + 1 | null | false |
PartialOrder.ext_lt | Mathlib.Order.Basic | ∀ {α : Type u_2} {A B : PartialOrder α}, (∀ (x y : α), x < y ↔ x < y) → A = B | null | true |
uniformity_hasBasis_open | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} [inst : UniformSpace α], (uniformity α).HasBasis (fun V => V ∈ uniformity α ∧ IsOpen V) id | Open elements of `𝓤 α` form a basis of `𝓤 α`. | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeft.TwoPowShiftTarget.noConfusionType | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | Sort u →
{α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeft.TwoPowShiftTarget aig w →
{α' : Type} →
[inst' : Hashable α'] →
[inst'_1 :... | null | false |
IntermediateField.extendRight.instSMulSubtypeMem | Mathlib.FieldTheory.IntermediateField.ExtendRight | {K : Type u_1} →
{L : Type u_2} →
[inst : Field K] →
[inst_1 : Field L] →
[inst_2 : Algebra K L] →
(F : IntermediateField K L) →
(M : Type u_3) →
[inst_3 : Field M] →
[inst_4 : Algebra K M] →
[inst_5 : Algebra L M] →
... | null | true |
TotallyBounded.exists_prodMk_finset_mem_hausdorffEntourage | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α] {s : Set α},
TotallyBounded s → ∀ {U : SetRel α α}, U ∈ uniformity α → ∃ t, (↑t, s) ∈ hausdorffEntourage U | null | true |
RatFunc.definition._@.Mathlib.FieldTheory.RatFunc.Defs.2943445235._hygCtx._hyg.2 | Mathlib.FieldTheory.RatFunc.Defs | {K : Type u} →
[inst : CommRing K] →
{P : Sort v} →
RatFunc K →
(f : Polynomial K → Polynomial K → P) →
(∀ {p q p' q' : Polynomial K},
q ∈ nonZeroDivisors (Polynomial K) →
q' ∈ nonZeroDivisors (Polynomial K) → q' * p = q * p' → f p q = f p' q') →
P | null | false |
CategoryTheory.Limits.lim_map | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Limits.HasLimitsOfShape J C] {X Y : CategoryTheory.Functor J C} (α : X ⟶ Y),
CategoryTheory.Limits.lim.map α = CategoryTheory.Limits.limMap α | null | true |
Lean.Lsp.instFromJsonRenameOptions.fromJson | Lean.Data.Lsp.LanguageFeatures | Lean.Json → Except String Lean.Lsp.RenameOptions | null | true |
Lean.Server.RpcEncodable.rec | Lean.Server.Rpc.Basic | {α : Type} →
{motive : Lean.Server.RpcEncodable α → Sort u} →
((rpcEncode : α → StateM Lean.Server.RpcObjectStore Lean.Json) →
(rpcDecode : Lean.Json → ExceptT String (ReaderT Lean.Server.RpcObjectStore Id) α) →
motive { rpcEncode := rpcEncode, rpcDecode := rpcDecode }) →
(t : Lean.Server.... | null | false |
_private.BatteriesRecycling.RBTree.Lemmas.0.Ordering.swap.match_1.eq_1 | BatteriesRecycling.RBTree.Lemmas | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.lt) (h_2 : Unit → motive Ordering.eq)
(h_3 : Unit → motive Ordering.gt),
(match Ordering.lt with
| Ordering.lt => h_1 ()
| Ordering.eq => h_2 ()
| Ordering.gt => h_3 ()) =
h_1 () | null | true |
BoxIntegral.Prepartition.distortion_of_const | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I) [inst : Fintype ι] {c : NNReal},
π.boxes.Nonempty → (∀ J ∈ π, J.distortion = c) → π.distortion = c | null | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.uniformSpace_eq_inf_precomp_of_cover._simp_1_3 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, (s ⊆ f ⁻¹' t) = (f '' s ⊆ t) | null | false |
CategoryTheory.Functor.cartesianMonoidalCategory._proof_7 | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} J]
[inst_1 : CategoryTheory.Category.{u_2, u_3} C] [inst_2 : CategoryTheory.CartesianMonoidalCategory C]
(X Y : CategoryTheory.Functor J C),
{ app := fun x => CategoryTheory.SemiCartesianMonoidalCategory.snd (X.obj x) (Y.obj x), naturality... | null | false |
Lean.Meta.SimpTheorems.isDeclToUnfold | Lean.Meta.Tactic.Simp.SimpTheorems | Lean.Meta.SimpTheorems → Lean.Name → Bool | Return `true` if `declName` is tagged to be unfolded using `unfoldDefinition?` (i.e., without using equational theorems). | true |
Unitization.ind | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_5} {A : Type u_6} [inst : AddZeroClass R] [inst_1 : AddZeroClass A] {P : Unitization R A → Prop},
(∀ (r : R) (a : A), P (Unitization.inl r + ↑a)) → ∀ (x : Unitization R A), P x | To show a property hold on all `Unitization R A` it suffices to show it holds
on terms of the form `inl r + a`.
This can be used as `induction x`. | true |
Representation.tprod._proof_1 | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_3} {G : Type u_4} {V : Type u_1} {W : Type u_2} [inst : CommSemiring k] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : Module k V] [inst_4 : AddCommMonoid W] [inst_5 : Module k W]
(ρV : Representation k G V) (ρW : Representation k G W), TensorProduct.map (ρV 1) (ρW 1) = 1 | null | false |
SemigroupAction.noConfusion | Mathlib.Algebra.Group.Action.Defs | {P : Sort u} →
{α : Type u_9} →
{β : Type u_10} →
{inst : Semigroup α} →
{t : SemigroupAction α β} →
{α' : Type u_9} →
{β' : Type u_10} →
{inst' : Semigroup α'} →
{t' : SemigroupAction α' β'} →
α = α' → β = β' → inst ≍ inst' → t ≍... | null | false |
Ordinal.omega_natCast_le_lift._simp_1 | Mathlib.SetTheory.Cardinal.Aleph | ∀ {o : Ordinal.{u}} {n : ℕ}, (Ordinal.omega ↑n ≤ Ordinal.lift.{v, u} o) = (Ordinal.omega ↑n ≤ o) | null | false |
sSup_range | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : SupSet α] {f : ι → α}, sSup (Set.range f) = iSup f | null | true |
_private.Batteries.Data.Vector.Basic.0.Vector.scanlMFast.loop._proof_3 | Batteries.Data.Vector.Basic | ∀ {n : ℕ} (i n_usize : USize), n_usize.toNat = n → i.toNat < n → (i + 1).toNat = i.toNat + 1 → (i + 1).toNat ≤ n | null | false |
Complex.polarCoord_symm_apply | Mathlib.Analysis.SpecialFunctions.PolarCoord | ∀ (p : ℝ × ℝ), ↑Complex.polarCoord.symm p = ↑p.1 * (↑(Real.cos p.2) + ↑(Real.sin p.2) * Complex.I) | null | true |
Multiset.sum_map_sum_map | Mathlib.Algebra.BigOperators.Group.Multiset.Basic | ∀ {ι : Type u_2} {κ : Type u_3} {M : Type u_5} [inst : AddCommMonoid M] (m : Multiset ι) (n : Multiset κ)
{f : ι → κ → M},
(Multiset.map (fun a => (Multiset.map (fun b => f a b) n).sum) m).sum =
(Multiset.map (fun b => (Multiset.map (fun a => f a b) m).sum) n).sum | null | true |
String.any_iff | Batteries.Data.String.Lemmas | ∀ (s : String) (p : Char → Bool), String.Legacy.any s p = true ↔ ∃ c ∈ s.toList, p c = true | null | true |
_private.Mathlib.Tactic.Linter.DirectoryDependency.0.Mathlib.Linter.initFn._@.Mathlib.Tactic.Linter.DirectoryDependency.458526677._hygCtx._hyg.4 | Mathlib.Tactic.Linter.DirectoryDependency | IO (Lean.Option Bool) | null | false |
Std.Do.SPred.or_intro_r' | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q R : Std.Do.SPred σs}, (P ⊢ₛ R) → P ⊢ₛ Q ∨ R | null | true |
Subbimodule.toSubmodule' | Mathlib.Algebra.Module.Bimodule | {R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{M : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[inst_3 : Semiring A] →
[inst_4 : Semiring B] →
[inst_5 : Module A M] →
... | Forgetting the `A` action, a `Submodule` over `A ⊗[R] B` is just a `Submodule` over `B`. | true |
CategoryTheory.Limits.pointwiseProductCompEvaluation._proof_2 | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesProduct | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_7, u_6} D] {α : Type u_3} {I : α → Type u_5}
[inst_2 : (i : α) → CategoryTheory.Category.{u_4, u_5} (I i)]
[inst_3 : CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete α) C]
(F : (i : ... | null | false |
Lean.Grind.LinarithConfig.instances._inherited_default | Init.Grind.Config | ℕ | null | false |
CategoryTheory.Pi.η_def | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] (i : I),
CategoryTheory.Functor.OplaxMonoidal.η (CategoryTheory.Pi.eval C i) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit... | null | true |
IsPrimitiveRoot.IsCyclotomicExtension.ringOfIntegersOfPrimePow | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {p k : ℕ} {K : Type u} [inst : Field K] [hp : Fact (Nat.Prime p)] [inst_1 : CharZero K]
[IsCyclotomicExtension {p ^ k} ℚ K], IsCyclotomicExtension {p ^ k} ℤ (NumberField.RingOfIntegers K) | The ring of integers of a `p ^ k`-th cyclotomic extension of `ℚ` is a cyclotomic extension. | true |
UInt8.ofFin_and | Init.Data.UInt.Bitwise | ∀ (a b : Fin UInt8.size), UInt8.ofFin (a &&& b) = UInt8.ofFin a &&& UInt8.ofFin b | null | true |
ZLattice.covolume.tendsto_card_le_div | Mathlib.Algebra.Module.ZLattice.Covolume | ∀ {ι : Type u_1} [inst : Fintype ι] (L : Submodule ℤ (ι → ℝ)) [inst_1 : DiscreteTopology ↥L] [IsZLattice ℝ L]
{X : Set (ι → ℝ)},
(∀ ⦃x : ι → ℝ⦄ ⦃r : ℝ⦄, x ∈ X → 0 < r → r • x ∈ X) →
∀ {F : (ι → ℝ) → ℝ},
(∀ (x : ι → ℝ) ⦃r : ℝ⦄, 0 ≤ r → F (r • x) = r ^ Fintype.card ι * F x) →
Bornology.IsBounded {x ... | null | true |
Std.TreeMap.Raw.getEntryLT! | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Inhabited (α × β)] → Std.TreeMap.Raw α β cmp → α → α × β | Tries to retrieve the key-value pair with the largest key that is less than the given key,
panicking if no such pair exists.
| true |
Std.HashSet.Raw.get!_erase | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : Inhabited α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k a : α}, (m.erase k).get! a = if (k == a) = true then default else m.get! a | null | true |
Matrix.isHermitian_iff_isSymm._simp_1 | Mathlib.LinearAlgebra.Matrix.Hermitian | ∀ {α : Type u_1} {n : Type u_4} [inst : Star α] [TrivialStar α] {A : Matrix n n α}, A.IsHermitian = A.IsSymm | null | false |
Complementeds.instMax._proof_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : BoundedOrder α] (a b : Complementeds α), IsComplemented (↑a ⊔ ↑b) | null | false |
ValuativeRel.IsNontrivial.rec | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | {R : Type u_1} →
[inst : Semiring R] →
[inst_1 : ValuativeRel R] →
{motive : ValuativeRel.IsNontrivial R → Sort u} →
((condition : ∃ γ, γ ≠ 0 ∧ γ ≠ 1) → motive ⋯) → (t : ValuativeRel.IsNontrivial R) → motive t | null | false |
norm_iteratedFDeriv_fderiv | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {n : ℕ}, ‖iteratedFDeriv 𝕜 n (fderiv 𝕜 f) x‖ = ‖iteratedFDeriv 𝕜 (n + 1) f x‖ | null | true |
NonUnitalNormedRing.rec | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} →
{motive : NonUnitalNormedRing α → Sort u} →
([toNorm : Norm α] →
[toNonUnitalRing : NonUnitalRing α] →
[toMetricSpace : MetricSpace α] →
(dist_eq : ∀ (x y : α), dist x y = ‖-x + y‖) →
(norm_mul_le : ∀ (a b : α), ‖a * b‖ ≤ ‖a‖ * ‖b‖) →
mo... | null | false |
Aesop.EqualUpToIds.Unsafe.exprsEqualUpToIdsCore₂ | Aesop.Util.EqualUpToIds | Lean.Expr → Lean.Expr → Aesop.EqualUpToIds.ExprsEqualUpToIdsM Bool | null | true |
Rep.Tor._proof_3 | Mathlib.RepresentationTheory.Homological.GroupHomology.Basic | ∀ (k G : Type u_1) [inst : CommRing k] [inst_1 : Group G],
CategoryTheory.HasProjectiveResolutions (Rep.{u_1, u_1, u_1} k G) | null | false |
nsmul_add | Mathlib.Algebra.Group.Basic | ∀ {M : Type u_4} [inst : AddCommMonoid M] (a b : M) (n : ℕ), n • (a + b) = n • a + n • b | null | true |
Lean.Meta.Grind.AC.EqCnstrProof.simp_middle.noConfusion | Lean.Meta.Tactic.Grind.AC.Types | {P : Sort u} →
{lhs : Bool} →
{s₁ s₂ : Lean.Grind.AC.Seq} →
{c₁ c₂ : Lean.Meta.Grind.AC.EqCnstr} →
{lhs' : Bool} →
{s₁' s₂' : Lean.Grind.AC.Seq} →
{c₁' c₂' : Lean.Meta.Grind.AC.EqCnstr} →
Lean.Meta.Grind.AC.EqCnstrProof.simp_middle lhs s₁ s₂ c₁ c₂ =
... | null | false |
_private.Lean.Meta.FunInfo.0.Lean.Meta.collectDeps.visit._f | Lean.Meta.FunInfo | Array Lean.Expr → (e : Lean.Expr) → Lean.Expr.below (motive := fun e => Array ℕ → Array ℕ) e → Array ℕ → Array ℕ | null | false |
CoxeterSystem.getElem_alternatingWord._proof_1 | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} (i j : B) (p k : ℕ), k < p → k < (CoxeterSystem.alternatingWord i j p).length | null | false |
IsJordan.casesOn | Mathlib.Algebra.Jordan.Basic | {A : Type u_1} →
[inst : Mul A] →
{motive : IsJordan A → Sort u} →
(t : IsJordan A) →
((lmul_comm_rmul : ∀ (a b : A), a * b * a = a * (b * a)) →
(lmul_lmul_comm_lmul : ∀ (a b : A), a * a * (a * b) = a * (a * a * b)) →
(lmul_lmul_comm_rmul : ∀ (a b : A), a * a * (b * a) = a ... | null | false |
Profinite.NobelingProof.iso_map._proof_3 | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u_1} (C : Set (I → Bool)) (J : I → Prop) [inst : (i : I) → Decidable (J i)],
Continuous fun x => ⟨fun i => ↑x ↑i, ⋯⟩ | null | false |
MaximalSpectrum.mk.injEq | Mathlib.RingTheory.Spectrum.Maximal.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] (asIdeal : Ideal R) (isMaximal : asIdeal.IsMaximal) (asIdeal_1 : Ideal R)
(isMaximal_1 : asIdeal_1.IsMaximal),
({ asIdeal := asIdeal, isMaximal := isMaximal } = { asIdeal := asIdeal_1, isMaximal := isMaximal_1 }) =
(asIdeal = asIdeal_1) | null | true |
Finset.singleton_div_singleton | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Div α] (a b : α), {a} / {b} = {a / b} | null | true |
WeierstrassCurve.HasMultiplicativeReduction.mk._flat_ctor | Mathlib.AlgebraicGeometry.EllipticCurve.Reduction | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] {K : Type u_2}
[inst_3 : Field K] [inst_4 : Algebra R K] [inst_5 : IsFractionRing R K] {W : WeierstrassCurve K},
MaximalFor (fun C => WeierstrassCurve.IsIntegral R (C • W)) (fun C => WeierstrassCurve.valuation_Δ_aux R (C... | null | false |
CategoryTheory.AddGrpObj.comp_zsmul | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{G X Y : C} [inst_2 : CategoryTheory.AddGrpObj G] (f : X ⟶ Y) (g : Y ⟶ G) (n : ℤ),
CategoryTheory.CategoryStruct.comp f (n • g) = n • CategoryTheory.CategoryStruct.comp f g | null | true |
AffineIsometryEquiv.coe_one | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V : Type u_2} {P : Type u_10} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup V]
[inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P] [inst_4 : NormedAddTorsor V P], ⇑1 = id | null | true |
CategoryTheory.Limits.inr_pushoutZeroZeroIso_hom | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C) [inst_3 : CategoryTheory.Limits.HasBinaryCoproduct X Y],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inr 0 0)
(Cat... | null | true |
ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice | Mathlib.Order.ConditionallyCompleteLattice.Defs | {α : Type u_5} → [self : ConditionallyCompleteLinearOrder α] → ConditionallyCompleteLattice α | null | true |
CategoryTheory.Functor.Fiber.homMk._proof_2 | Mathlib.CategoryTheory.FiberedCategory.Fiber | ∀ {𝒮 : Type u_1} {𝒳 : Type u_4} [inst : CategoryTheory.Category.{u_3, u_1} 𝒮]
[inst_1 : CategoryTheory.Category.{u_2, u_4} 𝒳] (p : CategoryTheory.Functor 𝒳 𝒮) (S : 𝒮) {a b : 𝒳} (φ : a ⟶ b)
[p.IsHomLift (CategoryTheory.CategoryStruct.id S) φ], p.obj b = S | null | false |
FreeGroup.instUniqueOfIsEmpty | Mathlib.GroupTheory.FreeGroup.Basic | {α : Type u} → [IsEmpty α] → Unique (FreeGroup α) | null | true |
Int.dvd_ediv_iff_mul_dvd._simp_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, c ∣ b → (a ∣ b / c) = (c * a ∣ b) | null | false |
Lean.Elab.Tactic.Do.Context.rec | Lean.Elab.Tactic.Do.VCGen.Basic | {motive : Lean.Elab.Tactic.Do.Context → Sort u} →
((config : Lean.Elab.Tactic.Do.VCGen.Config) →
(specThms : Lean.Elab.Tactic.Do.SpecAttr.SpecTheorems) →
(simpCtx : Lean.Meta.Simp.Context) →
(simprocs : Lean.Meta.Simp.SimprocsArray) →
(jps : Lean.FVarIdMap Lean.Elab.Tactic.Do.JumpS... | null | false |
Submonoid.decidableMemCentralizer | Mathlib.GroupTheory.Submonoid.Centralizer | {M : Type u_1} →
{S : Set M} →
[inst : Monoid M] → (a : M) → [Decidable (∀ b ∈ S, b * a = a * b)] → Decidable (a ∈ Submonoid.centralizer S) | null | true |
CategoryTheory.Monad.ReflectsColimitOfIsSplitPair.recOn | Mathlib.CategoryTheory.Monad.Monadicity | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₁, u₂} D] →
{G : CategoryTheory.Functor D C} →
{motive : CategoryTheory.Monad.ReflectsColimitOfIsSplitPair G → Sort u} →
(t : CategoryTheory.Monad.ReflectsColimitOf... | null | false |
Localization.localRingHom_bijective_of_not_conductor_le | Mathlib.RingTheory.Conductor | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {x : S} {P : Ideal S}
[inst_3 : P.IsPrime],
¬conductor R x ≤ P →
∀ {s : Subalgebra R S},
s = R[x] →
∀ (p : Ideal ↥s) [inst_4 : p.IsPrime] [inst_5 : P.LiesOver p],
Function.Bijective ⇑(Localiz... | null | true |
Module.instAEval._proof_7 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ (R : Type u_1) (M : Type u_2) {A : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M] [inst_6 : IsScalarTower R A M] (x : A)
(r s : R) (x_1 : Module.AEval R M x), (r + s) • x_1 = r • x_1 + s • x_1 | null | false |
List.idxOfNth_zero | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {x : α} [inst : BEq α], List.idxOfNth x xs 0 = List.idxOf x xs | null | true |
fderivWithin_const_add | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {s : Set E} (c : F), fderivWithin 𝕜 (fun y => c + f y) s x = fderivWithin 𝕜 f s x | null | true |
MeasureTheory.Measure.FiniteSpanningSetsIn.mono | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | {α : Type u_1} →
{m0 : MeasurableSpace α} →
{μ : MeasureTheory.Measure α} → {C D : Set (Set α)} → μ.FiniteSpanningSetsIn C → C ⊆ D → μ.FiniteSpanningSetsIn D | If `μ` has finite spanning sets in `C` and `C ⊆ D` then `μ` has finite spanning sets in `D`. | true |
intCyclicAddEquiv | Mathlib.GroupTheory.SpecificGroups.Cyclic | {G : Type u_2} → [Infinite G] → [inst : AddGroup G] → [IsAddCyclic G] → ℤ ≃+ G | An infinite cyclic additive group is isomorphic to `ℤ`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.