name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
OpenPartialHomeomorph.trans_of_set' | Mathlib.Topology.OpenPartialHomeomorph.Composition | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y) {s : Set Y} (hs : IsOpen s),
e.trans (OpenPartialHomeomorph.ofSet s hs) = e.restr (e.source ∩ ↑e ⁻¹' s) | null | true |
CategoryTheory.SmallObject.SuccStruct.Iteration.mkOfLimit.functor_obj | Mathlib.CategoryTheory.SmallObject.Iteration.Nonempty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {Φ : CategoryTheory.SmallObject.SuccStruct C}
{J : Type u} [inst_1 : LinearOrder J] [inst_2 : OrderBot J] [inst_3 : SuccOrder J] [inst_4 : WellFoundedLT J]
[inst_5 : CategoryTheory.Limits.HasIterationOfShape J C] {j : J} (hj : Order.IsSuccLimit j)
(it... | null | true |
Lean.Elab.Term.SyntheticMVarKind.coe.elim | Lean.Elab.Term.TermElabM | {motive : Lean.Elab.Term.SyntheticMVarKind → Sort u} →
(t : Lean.Elab.Term.SyntheticMVarKind) →
t.ctorIdx = 1 →
((header? : Option String) →
(expectedType e : Lean.Expr) →
(f? : Option Lean.Expr) →
(mkErrorMsg? : Option (Lean.MVarId → Lean.Expr → Lean.Expr → Lean.MetaM Le... | null | false |
_private.Mathlib.Algebra.Order.BigOperators.GroupWithZero.List.0.List.prod_pos._simp_1_2 | Mathlib.Algebra.Order.BigOperators.GroupWithZero.List | ∀ {α : Sort u_1} {a' : α} {P Q : α → Prop}, (∀ (a : α), a = a' ∨ Q a → P a) = (P a' ∧ ∀ (a : α), Q a → P a) | null | false |
Nonneg.monoidWithZero | Mathlib.Algebra.Order.Nonneg.Basic | {α : Type u_1} →
[inst : Semiring α] →
[inst_1 : PartialOrder α] → [ZeroLEOneClass α] → [AddLeftMono α] → [PosMulMono α] → MonoidWithZero (Nonneg α) | null | true |
CategoryTheory.Bicategory.conjugateEquiv_symm_id | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {c d : B} {l₁ : c ⟶ d} {r₁ : d ⟶ c}
(adj₁ : CategoryTheory.Bicategory.Adjunction l₁ r₁),
(CategoryTheory.Bicategory.conjugateEquiv adj₁ adj₁).symm (CategoryTheory.CategoryStruct.id r₁) =
CategoryTheory.CategoryStruct.id l₁ | null | true |
RBTree.RBNode.All_def | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {p : α → Prop} {t : RBTree.RBNode α}, RBTree.RBNode.All p t ↔ ∀ x ∈ t, p x | null | true |
_private.Mathlib.NumberTheory.ModularForms.LevelOne.GradedRing.0.ModularForm.E₄CubeSubE₆SqForm_isCuspForm | Mathlib.NumberTheory.ModularForms.LevelOne.GradedRing | ModularForm.E₄CubeSubE₆SqForm✝.IsCuspForm | null | true |
differentiable_circleMap | Mathlib.MeasureTheory.Integral.CircleIntegral | ∀ (c : ℂ) (R : ℝ), Differentiable ℝ (circleMap c R) | null | true |
CategoryTheory.Discrete.Hom.noConfusion | Mathlib.CategoryTheory.Discrete.Basic | {P : Sort u} →
{α : Type u₁} →
{a b : α} →
{t : CategoryTheory.Discrete.Hom a b} →
{α' : Type u₁} →
{a' b' : α'} →
{t' : CategoryTheory.Discrete.Hom a' b'} →
α = α' → a ≍ a' → b ≍ b' → t ≍ t' → CategoryTheory.Discrete.Hom.noConfusionType P t t' | null | false |
_private.Init.Data.Repr.0.Nat.toSuperDigitsAux.match_1 | Init.Data.Repr | (motive : ℕ → List Char → Sort u_1) →
(x : ℕ) → (x_1 : List Char) → ((n : ℕ) → (ds : List Char) → motive n ds) → motive x x_1 | null | false |
Lean.MetavarContext.LevelMVarToParam.Context.casesOn | Lean.MetavarContext | {motive : Lean.MetavarContext.LevelMVarToParam.Context → Sort u} →
(t : Lean.MetavarContext.LevelMVarToParam.Context) →
((paramNamePrefix : Lean.Name) →
(alreadyUsedPred : Lean.Name → Bool) →
(except : Lean.LMVarId → Bool) →
motive { paramNamePrefix := paramNamePrefix, alreadyUsedPre... | null | false |
CategoryTheory.MorphismProperty.universally_eq_iff | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C},
P.universally = P ↔ P.IsStableUnderBaseChange | null | true |
SSet.instNonemptyNOfNonempty | Mathlib.AlgebraicTopology.SimplicialSet.Nonempty | ∀ (X : SSet) [X.Nonempty], Nonempty X.N | null | true |
Filter.tendsto_iff_rtendsto' | Mathlib.Order.Filter.Partial | ∀ {α : Type u} {β : Type v} (l₁ : Filter α) (l₂ : Filter β) (f : α → β),
Filter.Tendsto f l₁ l₂ ↔ Filter.RTendsto' (Function.graph f) l₁ l₂ | null | true |
Std.HashMap.Raw.inner | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → Std.HashMap.Raw α β → Std.DHashMap.Raw α fun x => β | Internal implementation detail of the hash map | true |
Lean.LLVM.Builder._sizeOf_inst | Lean.Compiler.IR.LLVMBindings | {Context : Sort u_1} → (ctx : Context) → [SizeOf Context] → SizeOf (Lean.LLVM.Builder ctx) | null | false |
WeierstrassCurve.natDegree_preΨ_pos | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) {n : ℤ}, 2 < n.natAbs → ↑n ≠ 0 → 0 < (W.preΨ n).natDegree | null | true |
Set.piecewise_le | Mathlib.Data.Set.Piecewise | ∀ {α : Type u_1} {δ : α → Type u_7} [inst : (i : α) → Preorder (δ i)] {s : Set α} [inst_1 : (j : α) → Decidable (j ∈ s)]
{f₁ f₂ g : (i : α) → δ i}, (∀ i ∈ s, f₁ i ≤ g i) → (∀ i ∉ s, f₂ i ≤ g i) → s.piecewise f₁ f₂ ≤ g | null | true |
ShareCommon.StateFactoryImpl.mkState | Init.ShareCommon | (self : ShareCommon.StateFactoryImpl) → Unit → self.Map × self.Set | null | true |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabAppMatch.usingNames | Lean.PrettyPrinter.Delaborator.Builtins | {α : Type} →
Array Lean.Name → Lean.PrettyPrinter.Delaborator.DelabM α → optParam ℕ 0 → Lean.PrettyPrinter.Delaborator.DelabM α | null | true |
_private.Mathlib.Data.Nat.Choose.Basic.0.Nat.choose_pos.match_1_1 | Mathlib.Data.Nat.Choose.Basic | ∀ (motive : (x x_1 : ℕ) → x_1 ≤ x → Prop) (x x_1 : ℕ) (x_2 : x_1 ≤ x),
(∀ (x : ℕ) (hk : x ≤ 0), motive 0 x hk) →
(∀ (n : ℕ) (x : 0 ≤ n + 1), motive n.succ 0 x) →
(∀ (n n_1 : ℕ) (hk : n_1 + 1 ≤ n + 1), motive n.succ n_1.succ hk) → motive x x_1 x_2 | null | false |
QuadraticForm.toMatrix.congr_simp | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {N : Type u_5} {n : Type w} [inst : Fintype n] {inst_1 : DecidableEq n} [inst_2 : DecidableEq n]
[inst_3 : CommRing R] [inst_4 : Invertible 2] [inst_5 : AddCommGroup N] [inst_6 : Module R N]
(b b_1 : Module.Basis n R N),
b = b_1 →
∀ (Q Q_1 : QuadraticForm R N),
Q = Q_1 →
∀ (a a_... | null | true |
_private.Mathlib.RingTheory.Spectrum.Prime.Noetherian.0.PrimeSpectrum.instNoetherianSpace._proof_2 | Mathlib.RingTheory.Spectrum.Prime.Noetherian | 2 ≠ 0 | null | false |
Lean.IR.NormalizeIds.normArg | Lean.Compiler.IR.NormIds | Lean.IR.Arg → Lean.IR.NormalizeIds.M Lean.IR.Arg | null | true |
Polynomial.leadingCoeff_le_mapMahlerMeasure | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ {A : Type u_2} [inst : NormedRing A] (p : Polynomial A) (v : A →+* ℂ),
Isometry ⇑v → ‖p.leadingCoeff‖ ≤ p.mapMahlerMeasure v | null | true |
Matrix.det_mvPolynomialX_ne_zero | Mathlib.LinearAlgebra.Matrix.MvPolynomial | ∀ (m : Type u_1) (R : Type u_3) [inst : DecidableEq m] [inst_1 : Fintype m] [inst_2 : CommRing R] [Nontrivial R],
(Matrix.mvPolynomialX m m R).det ≠ 0 | In a nontrivial ring, `Matrix.mvPolynomialX m m R` has non-zero determinant. | true |
DistLat.Iso.mk._proof_6 | Mathlib.Order.Category.DistLat | ∀ {α β : DistLat} (e : ↑α ≃o ↑β) (a b : ↑β), e.symm (a ⊓ b) = e.symm a ⊓ e.symm b | null | false |
_private.Mathlib.Combinatorics.Matroid.Basic.0.Matroid.ExchangeProperty.antichain.match_1_1 | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {IsBase : Set α → Prop} {B B' : Set α} (x : α)
(motive : (∃ b ∈ B \ B', IsBase (insert b (B' \ {x}))) → Prop) (x_1 : ∃ b ∈ B \ B', IsBase (insert b (B' \ {x}))),
(∀ (w : α) (hy : w ∈ B \ B') (right : IsBase (insert w (B' \ {x}))), motive ⋯) → motive x_1 | null | false |
CategoryTheory.Functor.mapDerivedCategoryCompIso | Mathlib.Algebra.Homology.DerivedCategory.ExactFunctor | {C₁ : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Abelian C₁] →
[inst_2 : HasDerivedCategory C₁] →
{C₂ : Type u_2} →
[inst_3 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_4 : CategoryTheory.Abelian C₂] →
[inst_5 : HasDe... | If `F` and `G` are exact functors between abelian categories, the composition
of the induced functors on the derived category identifies to the functor
induced by `F ⋙ G`. | true |
MeasureTheory.StronglyMeasurable.measurableSet_lt | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {E : Type u_5} {m : MeasurableSpace α} {f g : α → E} [inst : TopologicalSpace E] [inst_1 : Preorder E]
[OrderClosedTopology E] [TopologicalSpace.PseudoMetrizableSpace E],
MeasureTheory.StronglyMeasurable f → MeasureTheory.StronglyMeasurable g → MeasurableSet {a | f a < g a} | null | true |
CategoryTheory.ProjectiveResolution._sizeOf_1 | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.Limits.HasZeroObject C} →
{inst_2 : CategoryTheory.Limits.HasZeroMorphisms C} →
{Z : C} → [SizeOf C] → CategoryTheory.ProjectiveResolution Z → ℕ | null | false |
RingNorm.funLike._proof_1 | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ {R : Type u_1} [inst : NonUnitalRing R] (f g : RingNorm R), (fun f => f.toFun) f = (fun f => f.toFun) g → f = g | null | false |
CochainComplex.HomComplex.Cocycle.fromSingleMk_postcomp._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X : C}
{K : CochainComplex C ℤ} {q : ℤ} (f : X ⟶ K.X q) (q' : ℤ),
CategoryTheory.CategoryStruct.comp f (K.d q q') = 0 →
∀ {L : CochainComplex C ℤ} (g : K ⟶ L),
CategoryTheory.CategoryStruct.comp (Catego... | null | false |
HomotopicalAlgebra.fibrations_over_iff | Mathlib.AlgebraicTopology.ModelCategory.Over | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (S : C) [inst_1 : HomotopicalAlgebra.CategoryWithFibrations C]
{X Y : CategoryTheory.Over S} (f : X ⟶ Y),
HomotopicalAlgebra.Fibration f ↔ HomotopicalAlgebra.Fibration (CategoryTheory.Over.Hom.left f) | null | true |
SimpleGraph.adjMatrix_mul_self_apply_self | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} (G : SimpleGraph V) [inst : DecidableRel G.Adj] [inst_1 : Fintype V]
[inst_2 : NonAssocSemiring α] (i : V), (SimpleGraph.adjMatrix α G * SimpleGraph.adjMatrix α G) i i = ↑(G.degree i) | null | true |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.subst | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Int.Internal.Linear.Var →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr →
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof | null | true |
Std.Http.URI.recOn | Std.Http.Data.URI.Basic | {motive : Std.Http.URI → Sort u} →
(t : Std.Http.URI) →
((scheme : Std.Http.URI.Scheme) →
(authority : Option Std.Http.URI.Authority) →
(path : Std.Http.URI.Path) →
(query : Option Std.Http.URI.Query) →
(fragment : Option String) →
motive
... | null | false |
Stream'.get_nats | Mathlib.Data.Stream.Init | ∀ (n : ℕ), Stream'.nats.get n = n | null | true |
AddEquiv.isAddHaarMeasure_map | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [inst_2 : TopologicalSpace G]
(μ : MeasureTheory.Measure G) [μ.IsAddHaarMeasure] [BorelSpace G] [ContinuousAdd G] {H : Type u_3}
[inst_6 : AddGroup H] [inst_7 : TopologicalSpace H] [inst_8 : MeasurableSpace H] [BorelSpace H]
[IsTopologicalAddGroup ... | A convenience wrapper for `MeasureTheory.Measure.isAddHaarMeasure_map`. | true |
QuotientAddGroup.lift_quot_mk | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} {M : Type u_4} [inst : AddGroup G] [inst_1 : AddMonoid M] (N : AddSubgroup G) [nN : N.Normal]
{φ : G →+ M} (HN : N ≤ φ.ker) (g : G),
(QuotientAddGroup.lift N φ HN) (Quot.mk (⇑(QuotientAddGroup.leftRel N)) g) = φ g | null | true |
USize.add_left_inj | Init.Data.UInt.Lemmas | ∀ {a b : USize} (c : USize), a + c = b + c ↔ a = b | null | true |
DifferentiableAt.comp_differentiableWithinAt | Mathlib.Analysis.Calculus.FDeriv.Comp | ∀ {𝕜 : 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] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → F} (x : E) {s : Set E} {g : ... | null | true |
_private.Mathlib.Data.Nat.Choose.Basic.0.Nat.choose_mul_add._proof_1_3 | Mathlib.Data.Nat.Choose.Basic | ∀ {m n : ℕ},
(m * (n - 1 + 1) + (n - 1) + 1) * (m * (n - 1 + 1) + (n - 1)).factorial =
(m * (n - 1 + 1) + (n - 1)).factorial * ((n - 1 + 1) * (m + 1)) | null | false |
instDecidableEqBinaryTree.decEq._proof_3 | Mathlib.Data.Tree.Basic | ∀ {α : Type u_1} (value : α) (left right : BinaryTree α), ¬BinaryTree.nil = BinaryTree.node value left right | null | false |
_private.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.HeapNode.rankTR.go.eq_2 | Batteries.Data.BinomialHeap.Basic | ∀ {α : Type u_1} (a : ℕ) (a_1 : α) (child s : Batteries.BinomialHeap.Imp.HeapNode α),
Batteries.BinomialHeap.Imp.HeapNode.rankTR.go✝ (Batteries.BinomialHeap.Imp.HeapNode.node a_1 child s) a =
Batteries.BinomialHeap.Imp.HeapNode.rankTR.go✝ s (a + 1) | null | true |
Submodule.mulMap'._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Submodule | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
MeasureTheory.Measure.measure_eq_right_of_subset_of_measure_add_eq | Mathlib.MeasureTheory.Measure.Module | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {s t : Set α},
(μ + ν) t ≠ ⊤ → s ⊆ t → (μ + ν) s = (μ + ν) t → ν s = ν t | null | true |
_private.Mathlib.GroupTheory.Coset.Basic.0.orbit_subgroup_eq_rightCoset.match_1_3 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] (s : Subgroup α) (a _b : α) (motive : _b ∈ MulOpposite.op a • ↑s → Prop)
(x : _b ∈ MulOpposite.op a • ↑s),
(∀ (c : α) (d : c ∈ ↑s) (e : (fun x => MulOpposite.op a • x) c = _b), motive ⋯) → motive x | null | false |
uniqueDiffWithinAt_of_mem_nhds | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : DivisionSemiring 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [inst_4 : TopologicalSpace 𝕜] [(nhdsWithin 0 {0}ᶜ).NeBot] [ContinuousSMul 𝕜 E] {x : E}
{s : Set E} [ContinuousAdd E], s ∈ nhds x → UniqueDiffWithinAt 𝕜 s x | null | true |
Algebra.IsQuadraticExtension.congr_simp | Mathlib.FieldTheory.Galois.Basic | ∀ (R : Type u_2) (S : Type u_3) [inst : CommSemiring R] [inst_1 : StrongRankCondition R] [inst_2 : Semiring S]
[inst_3 : Algebra R S], Algebra.IsQuadraticExtension R S = Algebra.IsQuadraticExtension R S | null | true |
MulAlgebraNorm.toAlgebraNorm._proof_1 | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | ∀ {R : outParam (Type u_2)} {S : outParam (Type u_1)} [inst : SeminormedCommRing R] [inst_1 : Ring S]
[inst_2 : Algebra R S] (f : MulAlgebraNorm R S) (x x_1 : S), f.toFun (x * x_1) ≤ f.toFun x * f.toFun x_1 | null | false |
MulActionHom.inverse_eq_inverse' | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {X : Type u_5} [inst : SMul M X] {Y₁ : Type u_8} [inst_1 : SMul M Y₁] (f : X →ₑ[id] Y₁) (g : Y₁ → X)
(h₁ : Function.LeftInverse g ⇑f) (h₂ : Function.RightInverse g ⇑f), f.inverse g h₁ h₂ = f.inverse' g ⋯ h₁ h₂ | null | true |
Subgroup.ofUnits_iSup₂ | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] {ι : Sort u_2} {κ : ι → Sort u_3} (f : (i : ι) → κ i → Subgroup Mˣ),
(⨆ i, ⨆ j, f i j).ofUnits = ⨆ i, ⨆ j, (f i j).ofUnits | null | true |
Ideal.FG.isNilpotent_iff_le_nilradical | Mathlib.RingTheory.Noetherian.Nilpotent | ∀ {R : Type u_1} [inst : CommSemiring R] {I : Ideal R}, I.FG → (IsNilpotent I ↔ I ≤ nilradical R) | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.letrec._regBuiltin.Lean.Parser.Termination.partialFixpoint.parenthesizer_95 | Lean.Parser.Term | IO Unit | null | false |
SupHomClass.rec | Mathlib.Order.Hom.Lattice | {F : Type u_6} →
{α : Type u_7} →
{β : Type u_8} →
[inst : Max α] →
[inst_1 : Max β] →
[inst_2 : FunLike F α β] →
{motive : SupHomClass F α β → Sort u} →
((map_sup : ∀ (f : F) (a b : α), f (a ⊔ b) = f a ⊔ f b) → motive ⋯) → (t : SupHomClass F α β) → motive t | null | false |
Float.Model.UnpackedFloat.unpackMantissa | Init.Data.Float.Model.Unpacked.Pack.Basic | {spec : Float.Model.Format} → BitVec spec.numBits → BitVec spec.mantissaBitsWithoutImplicit | Unpacks the mantissa portion of the packed float. If this is a normal number, this
will be missing the implicit bit.
| true |
Finset.Nontrivial.add_left | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : Add α] [IsLeftCancelAdd α] [inst_2 : DecidableEq α] {s t : Finset α},
t.Nontrivial → s.Nonempty → (s + t).Nontrivial | null | true |
CategoryTheory.GrothendieckTopology.Cover.multifork | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} →
{J : CategoryTheory.GrothendieckTopology C} →
{D : Type u₁} →
[inst_1 : CategoryTheory.Category.{v₁, u₁} D] →
(S : J.Cover X) → (P : CategoryTheory.Functor Cᵒᵖ D) → CategoryTheory.Limits.Multifork (S.index P) | The natural multifork associated to `S : J.Cover X` for a presheaf `P`.
Saying that this multifork is a limit is essentially equivalent to the sheaf condition at the
given object for the given covering sieve. See `Sheaf.lean` for an equivalent sheaf condition
using this.
| true |
Nat.mul_mul_mul_comm | Init.Data.Nat.Lemmas | ∀ (a b c d : ℕ), a * b * (c * d) = a * c * (b * d) | null | true |
Lean.PrettyPrinter.Delaborator.shouldOmitExpr | Lean.PrettyPrinter.Delaborator.Basic | Lean.Expr → Lean.PrettyPrinter.Delaborator.DelabM Bool | Returns `true` if, at the current depth, we should omit the term and use `⋯` rather than
delaborating it. This function can only return `true` if `pp.deepTerms` is set to `false`.
It also contains a heuristic to allow "shallow terms" to be delaborated, even if they appear deep in
an expression, which prevents terms suc... | true |
CategoryTheory.MonoidalCategory.externalProductSwap | Mathlib.CategoryTheory.Monoidal.ExternalProduct.Basic | (J₁ : Type u₁) →
(J₂ : Type u₂) →
(C : Type u₃) →
[inst : CategoryTheory.Category.{v₁, u₁} J₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} J₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
[inst_3 : CategoryTheory.MonoidalCategory C] →
[CategoryTheory.Braided... | When `C` is braided, there is an isomorphism `Prod.swap _ _ ⋙ F₁ ⊠ F₂ ≅ F₂ ⊠ F₁`, natural
in both `F₁` and `F₂`.
Note that `(externalProductSwap _ _ _).app (F₁, F₂) : Prod.swap _ _ ⋙ F₁ ⊠ F₂ ≅ F₂ ⊠ F₁`
type checks. | true |
UInt16.ofNat_toNat | Init.Data.UInt.Lemmas | ∀ {x : UInt16}, UInt16.ofNat x.toNat = x | null | true |
Mathlib.Meta.Positivity.evalNatSqrt | Mathlib.Tactic.Positivity.Basic | Mathlib.Meta.Positivity.PositivityExt | Extension for `Nat.sqrt`. | true |
_private.Lean.Expr.0.Lean.natLEPred | Lean.Expr | Lean.Expr | null | true |
MvPowerSeries.truncFinset_C | Mathlib.RingTheory.MvPowerSeries.Trunc | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] {s : Finset (σ →₀ ℕ)},
0 ∈ s → ∀ (r : R), (MvPowerSeries.truncFinset R s) (MvPowerSeries.C r) = MvPolynomial.C r | null | true |
MeasureTheory.AnalyticSet_def | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_3} [inst : TopologicalSpace α] (s : Set α),
MeasureTheory.AnalyticSet s = (s = ∅ ∨ ∃ f, Continuous f ∧ Set.range f = s) | null | true |
_private.Mathlib.Basic.Denumerable.0.Nat.Subtype.succ_le_of_lt.match_1_1 | Mathlib.Basic.Denumerable | ∀ {s : Set ℕ} {x y : ↑s} (motive : (∃ k, ↑x = ↑y + k + 1) → Prop) (x_1 : ∃ k, ↑x = ↑y + k + 1),
(∀ (k : ℕ) (hk : ↑x = ↑y + k + 1), motive ⋯) → motive x_1 | null | false |
Lean.Grind.CutsatConfig.ringMaxDegree._inherited_default | Init.Grind.Config | ℕ | null | false |
LinearOrderedAddCommGroup.zmultiplesOrderAddMonoidIso._proof_13 | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] (x : G)
(hxc : AddSubgroup.zmultiples x = AddSubgroup.zmultiples (max x (-x))) (z : ↥(AddSubgroup.zmultiples x)),
z ∈ AddSubgroup.zmultiples ⟨max x (-x), ⋯⟩ | null | false |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.ValidFor.get.match_1_1 | Batteries.Data.String.Lemmas | ∀ {l m₁ : List Char} {c : Char} {m₂ r : List Char}
(motive : (x : Substring.Raw) → Substring.Raw.ValidFor l (m₁ ++ c :: m₂) r x → Prop) (x : Substring.Raw)
(x_1 : Substring.Raw.ValidFor l (m₁ ++ c :: m₂) r x),
(∀ (_ : Unit),
motive
{ str := String.ofList (l ++ (m₁ ++ c :: m₂) ++ r), startPos := { by... | null | false |
_private.Mathlib.Algebra.MvPolynomial.Monad.0.MvPolynomial.vars_bind₁._simp_1_1 | Mathlib.Algebra.MvPolynomial.Monad | ∀ {α : Type u_1} (s : Finset α), (s ⊆ s) = True | null | false |
AddMonoidHom.mclosure_preimage_le | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (s : Set N),
AddSubmonoid.closure (⇑f ⁻¹' s) ≤ AddSubmonoid.comap f (AddSubmonoid.closure s) | null | true |
Std.Sat.AIG.RefVec.IfInput.noConfusion | Std.Sat.AIG.If | {P : Sort u} →
{α : Type} →
{inst : Hashable α} →
{inst_1 : DecidableEq α} →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
{t : Std.Sat.AIG.RefVec.IfInput aig w} →
{α' : Type} →
{inst' : Hashable α'} →
{inst'_1 : DecidableEq α'} →
... | null | false |
Batteries.BinomialHeap.Imp.Heap.WF.findMin._unsafe_rec | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
{le : α → α → Bool} →
{n : ℕ} →
{k : Batteries.BinomialHeap.Imp.Heap α → Batteries.BinomialHeap.Imp.Heap α} →
{res : Batteries.BinomialHeap.Imp.FindMin α} →
{s : Batteries.BinomialHeap.Imp.Heap α} →
Batteries.BinomialHeap.Imp.Heap.WF le n s →
Batt... | null | false |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Basic.0.String.Slice.startsWith_dropWhile._simp_1_2 | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {base : s.Pos}
{pos : (s.sliceFrom base).Pos},
String.Slice.Pattern.Model.MatchesAt pat pos =
String.Slice.Pattern.Model.MatchesAt pat (String.Slice.Pos.ofSliceFrom pos) | null | false |
_private.Init.Data.List.Monadic.0.List.zipWithM'.match_1.eq_2 | Init.Data.List.Monadic | ∀ {α : Type u_1} {β : Type u_2} (motive : List α → List β → Sort u_3) (x : List α) (x_1 : List β)
(h_1 : (x : α) → (xs : List α) → (y : β) → (ys : List β) → motive (x :: xs) (y :: ys))
(h_2 : (x : List α) → (x_2 : List β) → motive x x_2),
(∀ (x_2 : α) (xs : List α) (y : β) (ys : List β), x = x_2 :: xs → x_1 = y :... | null | true |
SeparationQuotient.outCLM_isUniformInducing | Mathlib.Topology.Algebra.SeparationQuotient.Section | ∀ (K : Type u_1) (E : Type u_2) [inst : DivisionRing K] [inst_1 : AddCommGroup E] [inst_2 : Module K E]
[inst_3 : UniformSpace E] [inst_4 : IsUniformAddGroup E] [inst_5 : ContinuousConstSMul K E],
IsUniformInducing ⇑(SeparationQuotient.outCLM K E) | null | true |
CategoryTheory.Functor.Fiber.fiberCategory._proof_1 | Mathlib.CategoryTheory.FiberedCategory.Fiber | ∀ {𝒮 : Type u_1} {𝒳 : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} 𝒮]
[inst_1 : CategoryTheory.Category.{u_2, u_3} 𝒳] {p : CategoryTheory.Functor 𝒳 𝒮} {S : 𝒮} {X Y Z : p.Fiber S}
(φ : { φ // p.IsHomLift (CategoryTheory.CategoryStruct.id S) φ })
(ψ : { φ // p.IsHomLift (CategoryTheory.CategoryStruct... | null | false |
Std.TreeMap.mem_insert._simp_1 | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k a : α} {v : β},
(a ∈ t.insert k v) = (cmp k a = Ordering.eq ∨ a ∈ t) | null | false |
Int.natAbs_negSucc | Init.Data.Int.Order | ∀ (n : ℕ), (Int.negSucc n).natAbs = n.succ | null | true |
Combinatorics.Line.map | Mathlib.Combinatorics.HalesJewett | {α : Type u_5} → {α' : Type u_6} → {ι : Type u_7} → (α → α') → Combinatorics.Line α ι → Combinatorics.Line α' ι | A function `f : α → α'` determines a function `line α ι → line α' ι`. For a coordinate `i`
`l.map f` is the identity at `i` if `l` is, and constantly `f y` if `l` is constantly `y` at `i`. | true |
ImportGraph.Widget.RpcEncodablePacket._@.ImportGraph.Widget.GoToModule.3734778248._hygCtx._hyg.1 | ImportGraph.Widget.GoToModule | Type | null | false |
IsClosed.neg | Mathlib.Topology.Algebra.Group.ContinuousInv | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : InvolutiveNeg G] [ContinuousNeg G] {s : Set G},
IsClosed s → IsClosed (-s) | null | true |
Filter.sdiff_liminf | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteBooleanAlgebra α] (f : Filter β) (u : β → α) (a : α),
a \ Filter.liminf u f = Filter.limsup (fun b => a \ u b) f | null | true |
AddSubmonoid.LocalizationMap.ofAddEquivOfDom_comp_symm | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N] {P : Type u_3}
[inst_2 : AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {k : P ≃+ M}
(H : AddSubmonoid.map k.toAddMonoidHom T = S) (x : M), (f.ofAddEquivOfDom H) (k.symm x) = f x | null | true |
_private.Lean.Widget.Diff.0.Lean.Widget.exprDiffCore.piDiff._unsafe_rec | Lean.Widget.Diff | Lean.SubExpr → Lean.SubExpr → Lean.MetaM Lean.Widget.ExprDiff✝ | null | false |
Function.locallyFinsuppWithin.instLattice._proof_4 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : Lattice Y] [inst_2 : Zero Y]
(D₁ D₂ : Function.locallyFinsuppWithin U Y), D₁ ≤ D₂ → D₂ ≤ D₁ → D₁ = D₂ | null | false |
Mathlib.Tactic.Ring.Common.ExProd.evalInv._sunfold | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
Mathlib.Tactic.Ring.Common.RingCompute bt sα →
Mathlib.Tactic.Ring.Common.RingCompute Mathlib.Tactic.Ring.Common.btℕ Mathlib.Tactic.Ring.Common.sℕ →
(dsα : Q(Semifield «$α»)) →
... | null | false |
Lean.Parser.ParserState.restore | Lean.Parser.Types | Lean.Parser.ParserState → ℕ → String.Pos.Raw → Lean.Parser.ParserState | null | true |
MeasureTheory.Measure.MutuallySingular | Mathlib.MeasureTheory.Measure.MutuallySingular | {α : Type u_1} → {x : MeasurableSpace α} → MeasureTheory.Measure α → MeasureTheory.Measure α → Prop | Two measures `μ`, `ν` are said to be mutually singular if there exists a measurable set `s`
such that `μ s = 0` and `ν sᶜ = 0`. | true |
groupCohomology.coboundaries₂ | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | {k G : Type u} → [inst : CommRing k] → [inst_1 : Group G] → (A : Rep.{u_1, u, u} k G) → Submodule k (G × G → ↑A) | The 2-coboundaries `B²(G, A)` of `A : Rep k G`, defined as the image of the map
`Fun(G, A) → Fun(G × G, A)` sending `(f, (g₁, g₂)) ↦ ρ_A(g₁)(f(g₂)) - f(g₁g₂) + f(g₁).` | true |
MeasureTheory.Lp.constL._proof_1 | Mathlib.MeasureTheory.Function.LpSpace.Indicator | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} (p : ENNReal) (μ : MeasureTheory.Measure α)
[inst : NormedAddCommGroup E] [inst_1 : MeasureTheory.IsFiniteMeasure μ] (x : E),
‖(MeasureTheory.Lp.const p μ) x‖ ≤ μ.real Set.univ ^ (1 / p.toReal) * ‖x‖ | null | false |
Filter.map_map₂_distrib_left | Mathlib.Order.Filter.NAry | ∀ {α : Type u_1} {α' : Type u_2} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {m : α → β → γ} {f : Filter α}
{g : Filter β} {n : γ → δ} {m' : α' → β → δ} {n' : α → α'},
(∀ (a : α) (b : β), n (m a b) = m' (n' a) b) → Filter.map n (Filter.map₂ m f g) = Filter.map₂ m' (Filter.map n' f) g | Symmetric statement to `Filter.map₂_map_left_comm`. | true |
TopologicalSpace.Clopens.mk.congr_simp | Mathlib.Topology.LocallyConstant.Basic | ∀ {α : Type u_4} [inst : TopologicalSpace α] (carrier carrier_1 : Set α) (e_carrier : carrier = carrier_1)
(isClopen' : IsClopen carrier),
{ carrier := carrier, isClopen' := isClopen' } = { carrier := carrier_1, isClopen' := ⋯ } | null | true |
_private.Mathlib.Analysis.Analytic.ChangeOrigin.0.FormalMultilinearSeries.changeOrigin_eval._simp_1_3 | Mathlib.Analysis.Analytic.ChangeOrigin | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
(p : FormalMultilinearSeries 𝕜 E F) {x y : E} (n : ℕ) (t : Finset (Fin n)),
(p n) (t.piecewise (fun x_1 => x)... | null | false |
Std.HashSet.size_diff_add_size_inter_eq_size_left | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α],
(m₁ \ m₂).size + (m₁ ∩ m₂).size = m₁.size | null | true |
NonUnitalNonAssocRing.left_distrib | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u} [self : NonUnitalNonAssocRing α] (a b c : α), a * (b + c) = a * b + a * c | Multiplication is left distributive over addition | true |
WithTop.instCompleteLinearOrder._proof_12 | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrderBot α] (a b : WithTop α), compare a b = compareOfLessAndEq a b | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.