name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AlgHomClass.toRingHomClass | Mathlib.Algebra.Algebra.Hom | ∀ {F : Type u_1} {R : outParam (Type u_2)} {A : outParam (Type u_3)} {B : outParam (Type u_4)} {inst : CommSemiring R}
{inst_1 : Semiring A} {inst_2 : Semiring B} {inst_3 : Algebra R A} {inst_4 : Algebra R B} {inst_5 : FunLike F A B}
[self : AlgHomClass F R A B], RingHomClass F A B | null | true |
suggestSteps | Mathlib.Tactic.Widget.Calc | Array Lean.SubExpr.GoalsLocation →
Lean.Expr → CalcParams → Lean.MetaM (String × String × Option (String.Pos.Raw × String.Pos.Raw)) | Return the link text and inserted text above and below of the calc widget. | true |
AddMonoidAlgebra.sup_support_list_prod_le | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {B : Type u_5} [inst : SemilatticeSup B] [inst_1 : OrderBot B] [inst_2 : Semiring R]
[inst_3 : AddMonoid A] [inst_4 : AddMonoid B] [AddLeftMono B] [AddRightMono B] {degb : A → B},
degb 0 ≤ 0 →
(∀ (a b : A), degb (a + b) ≤ degb a + degb b) →
∀ (l : List (AddMonoidAlgebra R A... | null | true |
Primrec.fst | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β], Primrec Prod.fst | null | true |
AffineSubspace.direction_bot | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) (V : Type u_2) (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P], ⊥.direction = ⊥ | The direction of `⊥` is the submodule `⊥`. | true |
_private.Mathlib.Data.List.InsertIdx.0.List.take_eraseIdx_eq_take_of_le._proof_1_1 | Mathlib.Data.List.InsertIdx | ∀ {α : Type u_1} (l : List α) (i j : ℕ), i ≤ j → (List.take i (l.eraseIdx j)).length = (List.take i l).length | null | false |
DerivedCategory.instPretriangulated._proof_1 | Mathlib.Algebra.Homology.DerivedCategory.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
(HomotopyCategory.subcategoryAcyclic C).trW.IsCompatibleWithTriangulation | null | false |
Mathlib.Linter.linter.upstreamableDecl.private | Mathlib.Tactic.Linter.UpstreamableDecl | Lean.Option Bool | If set to `true`, the `upstreamableDecl` linter will add warnings on private declarations.
| true |
connectedComponentIn_mem_nhds | Mathlib.Topology.Connected.LocallyConnected | ∀ {α : Type u} [inst : TopologicalSpace α] [LocallyConnectedSpace α] {F : Set α} {x : α},
F ∈ nhds x → connectedComponentIn F x ∈ nhds x | null | true |
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Modifiers.isPartial._sparseCasesOn_1 | Lean.Elab.DeclModifiers | {motive : Lean.Elab.RecKind → Sort u} →
(t : Lean.Elab.RecKind) → motive Lean.Elab.RecKind.partial → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
QuadraticMap.proj_apply | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {A : Type u_7} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : SMulCommClass R A A] [inst_4 : IsScalarTower R A A] {n : Type u_9} (i j : n) (x : n → A),
(QuadraticMap.proj i j) x = x i * x j | null | true |
TensorialAt.mkHom₂ | Mathlib.Geometry.Manifold.VectorBundle.Tensoriality | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
{I : ModelWithCorners 𝕜 E H} →
{M : Type u_4} →
... | Given an `A`-valued operation `Φ` on sections of vector bundles `V` and `V'` which is tensorial
at `x` in each argument, the construction `TensorialAt.mkHom₂` provides the associated continuous
linear map `V x →L[𝕜] V' x →L[𝕜] A`. | true |
UInt8.xor_right_inj | Init.Data.UInt.Bitwise | ∀ {a b : UInt8} (c : UInt8), c ^^^ a = c ^^^ b ↔ a = b | null | true |
_private.Lean.Meta.Tactic.Grind.AC.Seq.0.Lean.Grind.AC.instInhabitedStartsWithResult | Lean.Meta.Tactic.Grind.AC.Seq | Inhabited Lean.Grind.AC.StartsWithResult✝ | null | true |
AbsoluteValue.casesOn | Mathlib.Algebra.Order.AbsoluteValue.Basic | {R : Type u_5} →
{S : Type u_6} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : PartialOrder S] →
{motive : AbsoluteValue R S → Sort u} →
(t : AbsoluteValue R S) →
((toMulHom : R →ₙ* S) →
(nonneg' : ∀ (x : R), 0 ≤ toMulHom.toFun x) →
... | null | false |
Aesop.GoalId.mk | Aesop.Tree.Data | ℕ → Aesop.GoalId | null | true |
CovariantDerivative.finite_affine_combination._proof_3 | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F : Type u_5} [inst_6 : NormedAddCommG... | null | false |
zpow_one_add | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] (a : G) (n : ℤ), a ^ (1 + n) = a * a ^ n | null | true |
Subbimodule.mk._proof_5 | Mathlib.Algebra.Module.Bimodule | ∀ {R : Type u_4} {A : Type u_2} {B : Type u_3} {M : Type u_1} [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] [inst_6 : Module B M]
[inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R A M] [inst_10 : IsSca... | null | false |
Lean.mkPropEq | Lean.Expr | Lean.Expr → Lean.Expr → Lean.Expr | Given `a b : Prop`, returns `a = b` | true |
Absorbs.zero | Mathlib.Topology.Bornology.Absorbs | ∀ {M : Type u_1} {E : Type u_2} [inst : Bornology M] [inst_1 : Zero E] [inst_2 : SMulZeroClass M E] {s : Set E},
0 ∈ s → Absorbs M s 0 | null | true |
InformationTheory.klDiv_of_not_ac | Mathlib.InformationTheory.KullbackLeibler.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
¬μ.AbsolutelyContinuous ν → InformationTheory.klDiv μ ν = ⊤ | null | true |
CochainComplex.HomComplex.δ_comp_zero_cochain | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{F G K : CochainComplex C ℤ} {n₁ : ℤ} (z₁ : CochainComplex.HomComplex.Cochain F G n₁)
(z₂ : CochainComplex.HomComplex.Cochain G K 0) (m₁ : ℤ) (h₁ : n₁ + 1 = m₁),
CochainComplex.HomComplex.δ n₁ m₁ (z₁.comp z₂ ⋯) =
... | null | true |
MeasureTheory.Measure.haarMeasure_eq_iff | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [SecondCountableTopology G]
(K₀ : TopologicalSpace.PositiveCompacts G) (μ : MeasureTheory.Measure G) [MeasureTheory.SigmaFinite μ]
[μ.IsMulLeftInvariant], MeasureThe... | Let `μ` be a σ-finite left invariant measure on `G`. Then `μ` is equal to the Haar measure
defined by `K₀` iff `μ K₀ = 1`. | true |
Metric.instMetricSpaceInductiveLimit._proof_3 | Mathlib.Topology.MetricSpace.Gluing | ∀ {X : ℕ → Type u_1} [inst : (n : ℕ) → MetricSpace (X n)] {f : (n : ℕ) → X n → X (n + 1)}
{I : ∀ (n : ℕ), Isometry (f n)} (x : Metric.InductiveLimit I), dist x x = 0 | null | false |
FreeMonoid.lift_restrict | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {M : Type u_4} [inst : Monoid M] (f : FreeMonoid α →* M), FreeMonoid.lift (⇑f ∘ FreeMonoid.of) = f | null | true |
Filter.tendsto_atTop_atBot_of_antitone | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
Antitone f → (∀ (b : β), ∃ a, f a ≤ b) → Filter.Tendsto f Filter.atTop Filter.atBot | null | true |
CompTriple.instIsIdId | Mathlib.Logic.Function.CompTypeclasses | ∀ {M : Type u_1}, CompTriple.IsId id | null | true |
String.append_left_inj | Init.Data.String.Defs | ∀ {s₁ s₂ : String} (t : String), s₁ ++ t = s₂ ++ t ↔ s₁ = s₂ | null | true |
TwoUniqueSums.of_addOpposite | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u} [inst : Add G], TwoUniqueSums Gᵃᵒᵖ → TwoUniqueSums G | null | true |
SimpleGraph.Walk.support_concat | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (h : G.Adj v w), (p.concat h).support = p.support ++ [w] | null | true |
CategoryTheory.Cat.HasLimits.limitConeX_str | Mathlib.CategoryTheory.Category.Cat.Limit | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat),
(CategoryTheory.Cat.HasLimits.limitConeX F).str = inferInstance | null | true |
_private.Init.Data.String.Lemmas.Pattern.Split.Pred.0.String.Slice.toList_split_prop._simp_1_1 | Init.Data.String.Lemmas.Pattern.Split.Pred | ∀ {s : String.Slice} {p : Char → Prop} [inst : DecidablePred p],
List.map String.ofList (List.splitOnP (fun b => decide (p b)) s.copy.toList) =
List.map (String.Slice.copy ∘ String.Slice.Subslice.toSlice) (s.splitToSubslice p).toList | null | false |
Function.Injective.starMul._proof_2 | Mathlib.Algebra.Star.Basic | ∀ {R : Type u_1} {S : Type u_2} (f : R → S) [inst : Star R] [inst_1 : Mul R] [inst_2 : Mul S] [inst_3 : StarMul S]
(hf : Function.Injective f) (star : ∀ (x : R), f (star x) = star (f x)),
(∀ (x y : R), f (x * y) = f x * f y) → ∀ (x y : R), Star.star (x * y) = Star.star y * Star.star x | null | false |
CategoryTheory.Limits.pullbackConeOfRightIso_π_app_none | 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 g], (CategoryTheory.Limits.pullbackConeOfRightIso f g).π.app none = f | null | true |
Lean.Meta.Grind.ParentSet.mk | Lean.Meta.Tactic.Grind.Types | List Lean.Expr → Lean.Meta.Grind.ParentSet | null | true |
List.Vector.snoc.eq_1 | Mathlib.Data.Vector.Snoc | ∀ {α : Type u_1} {n : ℕ} (xs : List.Vector α n) (x : α), xs.snoc x = xs ++ x ::ᵥ List.Vector.nil | null | true |
Finsupp.equivMapDomain.eq_1 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] (f : α ≃ β) (l : α →₀ M),
Finsupp.equivMapDomain f l =
{ support := Finset.map f.toEmbedding l.support, toFun := fun a => l (f.symm a), mem_support_toFun := ⋯ } | null | true |
SemiRingCat.limitSemiring._aux_4 | Mathlib.Algebra.Category.Ring.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J SemiRingCat) →
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections] →
Semiring ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections →
(CategoryTheory.Limit... | null | false |
AlgHom.ext | Mathlib.Algebra.Algebra.Hom | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {φ₁ φ₂ : A →ₐ[R] B}, (∀ (x : A), φ₁ x = φ₂ x) → φ₁ = φ₂ | null | true |
Associated.instIsTrans | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : Monoid M], IsTrans M Associated | null | true |
Monoid.CoprodI.NeWord.head.eq_2 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (x x_1 j k : ι) (_hne : j ≠ k)
(w₁ : Monoid.CoprodI.NeWord M x j) (w₂ : Monoid.CoprodI.NeWord M k x_1), (w₁.append _hne w₂).head = w₁.head | null | true |
IsFiniteLength.brecOn | Mathlib.RingTheory.FiniteLength | ∀ {R : Type u_1} [inst : Ring R]
{motive : (M : Type u_2) → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → IsFiniteLength R M → Prop}
{M : Type u_2} {inst_1 : AddCommGroup M} {inst_2 : Module R M} (t : IsFiniteLength R M),
(∀ (M : Type u_2) [inst_3 : AddCommGroup M] [inst_4 : Module R M] (t : IsFiniteLength ... | null | true |
UniqueProds.casesOn | Mathlib.Algebra.Group.UniqueProds.Basic | {G : Type u_1} →
[inst : Mul G] →
{motive : UniqueProds G → Sort u} →
(t : UniqueProds G) →
((uniqueMul_of_nonempty :
∀ {A B : Finset G}, A.Nonempty → B.Nonempty → ∃ a0 ∈ A, ∃ b0 ∈ B, UniqueMul A B a0 b0) →
motive ⋯) →
motive t | null | false |
Int.ModEq.of_mul_right | Mathlib.Data.Int.ModEq | ∀ {n a b : ℤ} (m : ℤ), a ≡ b [ZMOD n * m] → a ≡ b [ZMOD n] | null | true |
Lean.Meta.Grind.EMatchTheoremPtr | Lean.Meta.Tactic.Grind.EMatchTheoremPtr | Type | null | true |
_private.Mathlib.AlgebraicGeometry.StructureSheaf.0.AlgebraicGeometry.StructureSheaf.toBasicOpenₗ_surjective._simp_1_1 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A}, (S ≤ T) = (↑S ⊆ ↑T) | null | false |
Std.Notify.wait | Std.Sync.Notify | Std.Notify → IO (Std.Async.AsyncTask Unit) | Wait to be notified. Returns a task that completes when notify is called.
Note: if notify was called before wait, this will wait for the next notify call.
| true |
_private.Mathlib.CategoryTheory.Bicategory.CatEnriched.0.CategoryTheory.CatEnriched.hComp_id._simp_1_1 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {α : Sort u_1} (a b : α), (a = b) = (a ≍ b) | null | false |
Matrix.mulVec_surjective_iff_isUnit | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {m : Type u} [inst : DecidableEq m] {R : Type u_2} [inst_1 : CommRing R] [inst_2 : Fintype m] {A : Matrix m m R},
Function.Surjective A.mulVec ↔ IsUnit A | null | true |
Set.Ici.coe_sup._simp_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} [inst : SemilatticeSup α] {a : α} {x y : ↑(Set.Ici a)}, ↑x ⊔ ↑y = ↑(x ⊔ y) | null | false |
_private.Mathlib.Data.Nat.Factorization.PrimePow.0.isPrimePow_iff_card_primeFactors_eq_one._simp_1_2 | Mathlib.Data.Nat.Factorization.PrimePow | ∀ (n : ℕ), n.primeFactors = n.factorization.support | null | false |
CategoryTheory.Bicategory.Pseudofunctor.ofLaxFunctorToLocallyGroupoid._proof_4 | Mathlib.CategoryTheory.Bicategory.LocallyGroupoid | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {B' : Type u_5} [inst_1 : CategoryTheory.Bicategory B']
[CategoryTheory.Bicategory.IsLocallyGroupoid B] (F : CategoryTheory.LaxFunctor B' B) {a b c : B'} (f : a ⟶ b)
(g : b ⟶ c), CategoryTheory.IsIso (F.mapComp f g) | null | false |
_private.Mathlib.Algebra.Lie.Cochain.0.LieModule.Cohomology.d₂₃Aux._proof_7 | Mathlib.Algebra.Lie.Cochain | ∀ (R : Type u_3) [inst : CommRing R] (L : Type u_2) [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (M : Type u_1)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [LieModule R L M]
(a : ↥(LieModule.Cohomology.twoCochain R L M)) (x : L) (x_1 : R) (x_2 : L) (x_3 : R) (x_4 : L),
⁅x, (a (x... | null | false |
_private.Init.Data.String.Defs.0.String.utf8ByteSize_eq_zero_iff._simp_1_1 | Init.Data.String.Defs | ∀ {s t : String}, (s = t) = (s.toByteArray = t.toByteArray) | null | false |
StrictConvexSpace.of_norm_add_ne_two | Mathlib.Analysis.Convex.StrictConvexSpace | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E],
(∀ ⦃x y : E⦄, ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ‖x + y‖ ≠ 2) → StrictConvexSpace ℝ E | null | true |
Module.injective_of_localization_maximal | Mathlib.RingTheory.LocalProperties.Injective | ∀ {R : Type u} [inst : CommRing R] {M : Type v} [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Small.{v, u} R]
[IsNoetherianRing R],
(∀ (I : Ideal R) (x : I.IsMaximal), Module.Injective (Localization.AtPrime I) (LocalizedModule I.primeCompl M)) →
Module.Injective R M | null | true |
CompHausLike.LocallyConstant.adjunction | Mathlib.Condensed.Discrete.LocallyConstant | (P : TopCat → Prop) →
[∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)] →
[inst : CompHausLike.HasProp P PUnit.{u + 1}] →
[inst_1 : CompHausLike.HasExplicitFiniteCoproducts P] →
[inst_2 : CompHausLike.HasExplicitPullbacks P] →
(hs :
∀ ⦃X Y : C... | `CompHausLike.LocallyConstant.functor` is left adjoint to the forgetful functor.
| true |
FirstOrder.Language.Relations.formula₂.eq_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {α : Type u'} (r : L.Relations 2) (t₁ t₂ : L.Term α), r.formula₂ t₁ t₂ = r.formula ![t₁, t₂] | null | true |
Int.subNatNat_sub | Init.Data.Int.Lemmas | ∀ {n m : ℕ}, n ≤ m → ∀ (k : ℕ), Int.subNatNat (m - n) k = Int.subNatNat m (k + n) | null | true |
MeasureTheory.Lp.zero_smul | Mathlib.MeasureTheory.Function.Holder | ∀ {α : Type u_1} (𝕜 : Type u_3) {E : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (p : ENNReal)
{q r : ENNReal} [hpqr : p.HolderTriple q r] [inst : NormedRing 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : IsBoundedSMul 𝕜 E] (f : ↥(MeasureTheory.Lp E q μ)), 0 • f = 0 | null | true |
_private.Init.Data.AC.0.Lean.Data.AC.removeNeutrals.loop.match_1.eq_1 | Init.Data.AC | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match true with
| true => h_1 ()
| false => h_2 ()) =
h_1 () | null | true |
Manifold.«_aux_Mathlib_Geometry_Manifold_Notation___elabRules_Manifold_termHasMFDerivAt%_______1» | Mathlib.Geometry.Manifold.Notation | Lean.Elab.Term.TermElab | `HasMFDerivAt% f x f'` elaborates to `HasMFDerivAt I J f x f'`,
trying to determine `I` and `J` from the local context. | false |
_private.Lean.Compiler.ExportAttr.0.Lean.isValidCppName | Lean.Compiler.ExportAttr | Lean.Name → Bool | null | true |
Ordinal.veblen_left_monotone | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}), Monotone fun x => Ordinal.veblen x o | null | true |
AlgebraicGeometry.Scheme.OpenCover.pullbackCoverAffineRefinementObjIso_inv_pullbackHom_assoc | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : Y.OpenCover)
(i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰.affineRefinement.openCover).I₀)
{Z : AlgebraicGeometry.Scheme} (h : 𝒰.affineRefinement.openCover.X i ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.OpenCover.pullba... | null | true |
Aesop.EqualUpToIdsM.Context._sizeOf_1 | Aesop.Util.EqualUpToIds | Aesop.EqualUpToIdsM.Context → ℕ | null | false |
CategoryTheory.Lax.LaxTrans.StrongCore.mk.inj | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.LaxFunctor B C} {η : F ⟶ G}
{naturality :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (η.app a) (G.map f) ≅ CategoryTheory.CategoryStruct.comp (F.map f) ... | null | true |
Lean.Meta.Grind.CnstrRHS.mk.inj | Lean.Meta.Tactic.Grind.Extension | ∀ {levelNames : Array Lean.Name} {numMVars : ℕ} {expr : Lean.Expr} {levelNames_1 : Array Lean.Name} {numMVars_1 : ℕ}
{expr_1 : Lean.Expr},
{ levelNames := levelNames, numMVars := numMVars, expr := expr } =
{ levelNames := levelNames_1, numMVars := numMVars_1, expr := expr_1 } →
levelNames = levelNames_1 ∧... | null | true |
CategoryTheory.Limits.pullbackRightPullbackFstIso_hom_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) (f' : W ⟶ X)
[inst_1 : CategoryTheory.Limits.HasPullback f g]
[inst_2 : CategoryTheory.Limits.HasPullback f' (CategoryTheory.Limits.pullback.fst f g)] {Z_1 : C} (h : Y ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (Categor... | null | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxsOf_lt._proof_1_11 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs : List α} {x : α} {s : ℕ} [inst : BEq α] (h : i < (List.idxsOf x xs s).length),
(List.findIdxs (fun x_1 => x_1 == x) xs)[0] < xs.length | null | false |
_private.Mathlib.RingTheory.HahnSeries.Basic.0.HahnSeries.ext.match_1 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_2} {inst : PartialOrder Γ} {inst_1 : Zero R} (motive : HahnSeries Γ R → Prop)
(h : HahnSeries Γ R),
(∀ (coeff : Γ → R) (isPWO_support' : (Function.support coeff).IsPWO),
motive { coeff := coeff, isPWO_support' := isPWO_support' }) →
motive h | null | false |
MeasureTheory.Measure.IsOpenPosMeasure.mk | Mathlib.MeasureTheory.Measure.OpenPos | ∀ {X : Type u_1} [inst : TopologicalSpace X] {m : MeasurableSpace X} {μ : MeasureTheory.Measure X},
(∀ (U : Set X), IsOpen U → U.Nonempty → μ U ≠ 0) → μ.IsOpenPosMeasure | null | true |
Denumerable.nat | Mathlib.Logic.Denumerable | Denumerable ℕ | null | true |
groupHomology.single_isCycle₁_of_mem_fixedPoints | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {G : Type u_1} {A : Type u_2} [inst : Group G] [inst_1 : AddCommGroup A] [inst_2 : DistribMulAction G A] (g : G),
∀ a ∈ MulAction.fixedPoints G A, groupHomology.IsCycle₁ fun₀ | g => a | null | true |
AddConstMap.instMonoid | Mathlib.Algebra.AddConstMap.Basic | {G : Type u_1} → [inst : Add G] → {a : G} → Monoid (AddConstMap G G a a) | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.EqCnstr.0.Lean.Meta.Grind.Arith.CommRing.toRingExpr?.match_1 | Lean.Meta.Tactic.Grind.Arith.CommRing.EqCnstr | (motive : Option Lean.Grind.CommRing.Var → Sort u_1) →
(x : Option Lean.Grind.CommRing.Var) →
((x : Lean.Grind.CommRing.Var) → motive (some x)) → ((x : Option Lean.Grind.CommRing.Var) → motive x) → motive x | null | false |
_private.Init.Data.Option.Monadic.0.Option.instForIn'InferInstanceMembershipOfMonad.match_1.eq_1 | Init.Data.Option.Monadic | ∀ {β : Type u_1} (motive : ForInStep β → Sort u_2) (r : β) (h_1 : (r : β) → motive (ForInStep.done r))
(h_2 : (r : β) → motive (ForInStep.yield r)),
(match ForInStep.done r with
| ForInStep.done r => h_1 r
| ForInStep.yield r => h_2 r) =
h_1 r | null | true |
_private.Init.Data.Int.LemmasAux.0.Int.ble'_eq_true._proof_1_2 | Init.Data.Int.LemmasAux | ∀ (a a_1 : ℕ), ¬Int.negSucc a_1 < ↑a → False | null | false |
LightCondensed.finYoneda._proof_1 | Mathlib.Condensed.Discrete.Colimit | ∀ (F : CategoryTheory.Functor LightProfiniteᵒᵖ (Type u_1)) (X : FintypeCatᵒᵖ),
(TypeCat.ofHom fun g => g ∘ ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X).unop)) =
CategoryTheory.CategoryStruct.id
((Opposite.unop X).obj → F.obj (FintypeCat.toLightProfinite.op.obj (Opposite.op (Fin... | null | false |
submonoidOfIdempotent._proof_1 | Mathlib.GroupTheory.OrderOfElement | ∀ {M : Type u_1} [inst : LeftCancelMonoid M] (S : Set M), S * S = S → ∀ a ∈ S, ∀ (n : ℕ), a ^ (n + 1) ∈ S | null | false |
RootPairing.exist_set_root_not_disjoint_and_le_ker_coroot'_of_invtSubmodule | Mathlib.LinearAlgebra.RootSystem.Irreducible | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) [NeZero 2]
[IsDomain R] [Module.IsTorsionFree R M] (q : Submodule R M),
(∀ (i : ι), q ∈ Module.End.invtSubmodu... | null | true |
_private.Mathlib.Order.Filter.Basic.0.Filter.frequently_principal._simp_1_2 | Mathlib.Order.Filter.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
_private.Mathlib.RingTheory.FiniteType.0.AddMonoidAlgebra.finiteType_iff_fg._simp_1_1 | Mathlib.RingTheory.FiniteType | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M},
(x ∈ ⊤) = True | null | false |
MeasureTheory.integrableOn_indicator_iff | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {ε' : Type u_4} {mα : MeasurableSpace α} {s t : Set α} {μ : MeasureTheory.Measure α}
[inst : TopologicalSpace ε'] [inst_1 : ESeminormedAddMonoid ε'] {f : α → ε'},
MeasurableSet s → (MeasureTheory.IntegrableOn (s.indicator f) t μ ↔ MeasureTheory.IntegrableOn f (s ∩ t) μ) | null | true |
SimpleGraph.Walk.IsPath.of_append_left | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} {p : G.Walk u v} {q : G.Walk v w}, (p.append q).IsPath → p.IsPath | null | true |
Lean.Meta.Grind.traceEMatchDiagsCompact | Lean.Meta.Tactic.Grind.Main | Lean.PArray Lean.Meta.Grind.EMatchDiagInfo → Lean.Meta.Grind.GrindM Unit | null | true |
Lean.mkIntDvd | Lean.Expr | Lean.Expr → Lean.Expr → Lean.Expr | Given `a b : Int`, returns `a ∣ b` | true |
MulActionHom.comp_inverse' | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [inst : SMul M X] {Y : Type u_6} [inst_1 : SMul N Y]
{φ' : N → M} {f : X →ₑ[φ] Y} {g : Y → X} {k₁ : Function.LeftInverse φ' φ} {k₂ : Function.RightInverse φ' φ}
{h₁ : Function.LeftInverse g ⇑f} {h₂ : Function.RightInverse g ⇑f}, (f.inverse' g k₂ h₁ h₂).comp... | null | true |
eVariationOn.eVariationOn_inter_Ioi_eq_inter_Ici_of_continuousWithinAt | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : PseudoEMetricSpace E] [inst_2 : TopologicalSpace α]
[OrderTopology α] {f : α → E} {s : Set α} {a : α},
(nhdsWithin a (s ∩ Set.Ioi a)).NeBot →
ContinuousWithinAt f (s ∩ Set.Ici a) a → eVariationOn f (s ∩ Set.Ioi a) = eVariationOn f (s ∩ Set.Ici a) | If a function is continuous on the right at a point `a`, then its variations on `Ioi a` and
on `Ici a` coincide. We give a version relative to a set `s`. | true |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.evalAlts.applyAltStx | Lean.Elab.Tactic.Induction | Lean.Meta.ElimInfo →
Lean.Syntax →
ℕ →
Array Lean.FVarId →
Array Lean.FVarId →
Array (Lean.Ident × Lean.FVarId) →
Array (Lean.Language.SnapshotBundle Lean.Elab.Tactic.TacticParsedSnapshot) →
Array Lean.Syntax → ℕ → Lean.Syntax → Lean.Elab.Tactic.ElimApp.Alt → Lean... | Applies syntactic alternative to alternative goal. | true |
Finset.addEnergy_pos | Mathlib.Combinatorics.Additive.Energy | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Add α] {s t : Finset α}, s.Nonempty → t.Nonempty → 0 < s.addEnergy t | null | true |
ModuleCat.hom_surjective | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u} [inst : Ring R] {M N : ModuleCat R}, Function.Surjective ModuleCat.Hom.hom | Convenience shortcut for `ModuleCat.hom_bijective.surjective`. | true |
Finset.compls_inter | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : BooleanAlgebra α] [inst_1 : DecidableEq α] (s t : Finset α),
(s ∩ t).compls = s.compls ∩ t.compls | null | true |
alternatingGroup.iwasawaStructure_three._proof_1 | Mathlib.GroupTheory.SpecificGroups.Alternating.Simple | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (s : ↑(Set.powersetCard α 3)),
IsMulCommutative ↥(alternatingGroup.ofSubtype ↑s).range | null | false |
Matroid.IsCircuit.eq_of_superset_isCircuit | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {M : Matroid α} {C C' : Set α}, M.IsCircuit C → M.IsCircuit C' → C' ⊆ C → C = C' | null | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation.0.CFC.exists_measure_nnrpow_eq_integral_cfcₙ_rpowIntegrand₀₁._proof_1_6 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ (A : Type u_1) [inst : NonUnitalNormedRing A] [inst_1 : NormedSpace ℝ A] [inst_2 : PartialOrder A]
[NonnegSpectrumClass ℝ A] (a : A), 0 ≤ a → ∀ r ∈ quasispectrum ℝ a, r ∈ Set.Ici 0 | null | false |
Filter.iSup_liminf_le_liminf_iSup | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : CompleteLattice α] {f : Filter β} {u : ι → β → α},
⨆ i, Filter.liminf (u i) f ≤ Filter.liminf (fun b => ⨆ i, u i b) f | null | true |
AlgebraicGeometry.Scheme.Modules.Hom.mapPresheaf | Mathlib.AlgebraicGeometry.Modules.Sheaf | {X : AlgebraicGeometry.Scheme} → {M N : X.Modules} → (M ⟶ N) → (M.presheaf ⟶ N.presheaf) | The underlying map between abelian presheaves of a morphism of `𝒪ₓ`-modules. | true |
Lean.Core.SavedState.messages._inherited_default | Lean.CoreM | Lean.MessageLog | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.