name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Meta.Tactic.Grind.PropagateInj.0.Lean.Meta.Grind.getInvFor? | Lean.Meta.Tactic.Grind.PropagateInj | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM (Option (Lean.Expr × Lean.Expr)) | null | true |
CategoryTheory.Abelian.SpectralObject.homologyDataIdId._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
_private.Batteries.Util.ProofWanted.0.elabWanted.match_11 | Batteries.Util.ProofWanted | (motive : Option Lean.LocalDecl → Sort u_1) →
(x : Option Lean.LocalDecl) →
((d : Lean.LocalDecl) → motive (some d)) → ((x : Option Lean.LocalDecl) → motive x) → motive x | null | false |
Quaternion.imI_sub | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a b : Quaternion R), (a - b).imI = a.imI - b.imI | null | true |
LE.le.lt_or_eq_dec | Mathlib.Order.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α} [DecidableLE α], a ≤ b → a < b ∨ a = b | **Alias** of `Decidable.lt_or_eq_of_le`. | true |
Int.dvd_add_self_mul | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, a ∣ b + a * c ↔ a ∣ b | null | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.ParamMap.noConfusionType | Lean.Compiler.LCNF.InferBorrow | Sort u → Lean.Compiler.LCNF.ParamMap✝ → Lean.Compiler.LCNF.ParamMap✝ → Sort u | null | false |
Lean.Meta.Grind.instInhabitedEntry | Lean.Meta.Tactic.Grind.Extension | Inhabited Lean.Meta.Grind.Entry | null | true |
List.findIdx_singleton | Init.Data.List.Find | ∀ {α : Type u_1} {a : α} {p : α → Bool}, List.findIdx p [a] = if p a = true then 0 else 1 | null | true |
_private.Aesop.Options.Public.0.Aesop.initFn._@.Aesop.Options.Public.3910975230._hygCtx._hyg.4 | Aesop.Options.Public | IO (Lean.Option String) | null | false |
Pi.Lex.wellFounded | Mathlib.Data.DFinsupp.WellFounded | ∀ {ι : Type u_1} {α : ι → Type u_2} (r : ι → ι → Prop) {s : (i : ι) → α i → α i → Prop} [IsStrictTotalOrder ι r]
[Finite ι] [hs : ∀ (i : ι), WellFounded (s i)], WellFounded (Pi.Lex r fun {i} => s i) | null | true |
LinearEquiv.conjRingEquiv._proof_1 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_1} {R₂ : Type u_4} {M₁ : Type u_2} {M₂ : Type u_3} [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₂} {σ₂₁ : R₂ →+* R₁} [inst_6 : RingHomInvPair σ₁₂ σ₂₁] [inst_7 : RingHomInvPair σ₂₁ σ₁₂... | null | false |
_private.Mathlib.Topology.Instances.Irrational.0.dense_irrational._simp_1_2 | Mathlib.Topology.Instances.Irrational | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | null | false |
InfiniteGalois.GaloisCoinsertionIntermediateFieldSubgroup._proof_2 | Mathlib.FieldTheory.Galois.Infinite | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] [IsGalois k K]
(K_1 : IntermediateField k K),
((fun H => IntermediateField.fixedField H) ∘ ⇑OrderDual.toDual)
((⇑OrderDual.toDual ∘ fun E => E.fixingSubgroup) K_1) ≤
K_1 | null | false |
Aesop.RuleStatsTotals.compareByTotalElapsed | Aesop.Stats.Basic | Aesop.RuleStatsTotals → Aesop.RuleStatsTotals → Ordering | null | true |
CategoryTheory.toPresheafToSheafCompComposeAndSheafify | Mathlib.CategoryTheory.Sites.PreservesSheafification | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
{A : Type u_1} →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} A] →
[inst_2 : CategoryTheory.Category.{v_2, u_2} B] →
(F : CategoryTheory.Funct... | The canonical natural transformation from
`(whiskeringRight Cᵒᵖ A B).obj F ⋙ presheafToSheaf J B` to
`presheafToSheaf J A ⋙ Sheaf.composeAndSheafify J F`. | true |
Isometry.isometryEquivOnRange | Mathlib.Topology.MetricSpace.Isometry | {α : Type u} →
{β : Type v} →
[inst : EMetricSpace α] → [inst_1 : PseudoEMetricSpace β] → {f : α → β} → Isometry f → α ≃ᵢ ↑(Set.range f) | An isometry induces an isometric isomorphism between the source space and the
range of the isometry. | true |
Ideal.instAddCommGroupCotangent._proof_9 | Mathlib.RingTheory.Ideal.Cotangent | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R),
autoParam (∀ (n : ℕ) (x : I.Cotangent), (n + 1) • x = n • x + x) AddMonoid.nsmul_succ._autoParam | null | false |
Std.Do.SPred.entails.trans' | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q R : Std.Do.SPred σs}, (P ⊢ₛ Q) → (P ∧ Q ⊢ₛ R) → P ⊢ₛ R | null | true |
Iff.not | Mathlib.Basic.Logic.Basic | ∀ {a b : Prop}, (a ↔ b) → (¬a ↔ ¬b) | **Alias** of `not_congr`. | true |
_private.Mathlib.RingTheory.PowerSeries.Schroder.0.PowerSeries.largeSchroderSeries_eq_one_add_X_mul_largeSchroderSeries_add_X_mul_largeSchroderSeries_sq._proof_1_3 | Mathlib.RingTheory.PowerSeries.Schroder | ∀ (n : ℕ), 0 < n → ¬n = n - 1 + 1 → False | null | false |
SimpleGraph.Walk.IsCircuit.egirth_le_length | Mathlib.Combinatorics.SimpleGraph.Girth | ∀ {α : Type u_1} {G : SimpleGraph α} {a : α} {w : G.Walk a a}, w.IsCircuit → G.egirth ≤ ↑w.length | null | true |
Subarray.mkSlice_roc_eq_mkSlice_rcc | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {lo hi : ℕ},
Std.Roc.Sliceable.mkSlice xs (lo<...=hi) = Std.Rcc.Sliceable.mkSlice xs (lo + 1...=hi) | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.whereDecls._regBuiltin.Lean.Parser.Term.whereFinallySubsection.parenthesizer_15 | Lean.Parser.Term | IO Unit | null | false |
AddSubmonoid.toNatSubmodule._proof_2 | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {M : Type u_1} [inst : AddCommMonoid M],
Function.RightInverse Submodule.toAddSubmonoid fun S => { toAddSubmonoid := S, smul_mem' := ⋯ } | null | false |
List.findIdxNth.eq_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (p : α → Bool) (xs : List α) (n : ℕ), List.findIdxNth p xs n = List.findIdxNth.go p xs n 0 | null | true |
_private.Mathlib.Geometry.Manifold.VectorField.LieBracket.0.VectorField.mpullback_mlieBracket._simp_1_2 | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : 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] {E' : Type u_5} [inst_6 : NormedAddComm... | null | false |
Lean.IR.FnBody.set | Lean.Compiler.IR.Basic | Lean.IR.VarId → ℕ → Lean.IR.Arg → Lean.IR.FnBody → Lean.IR.FnBody | Store `y` at Position `sizeof(void*)*i` in `x`. `x` must be a Constructor object and `RC(x)` must be 1.
This operation is not part of λPure is only used during optimization. | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex.0.SSet.Subcomplex.Pairing.RankFunction.range_homOfLE_app_union_range_b_app._simp_1_2 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∪ b) = (x ∈ a ∨ x ∈ b) | null | false |
Std.Tactic.BVDecide.BVUnOp.arithShiftRightConst.injEq | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (n n_1 : ℕ),
(Std.Tactic.BVDecide.BVUnOp.arithShiftRightConst n = Std.Tactic.BVDecide.BVUnOp.arithShiftRightConst n_1) = (n = n_1) | null | true |
Real.instNormedAddCommGroupAngle._proof_30 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ (x y z : Real.Angle), dist x z ≤ dist x y + dist y z | null | false |
Std.IterM.TerminationMeasures.Finite.mk._flat_ctor | Init.Data.Iterators.Basic | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} → [inst : Std.Iterator α m β] → Std.IterM m β → Std.IterM.TerminationMeasures.Finite α m | null | false |
Lean.JsonNumber.recOn | Lean.Data.Json.Basic | {motive : Lean.JsonNumber → Sort u} →
(t : Lean.JsonNumber) →
((mantissa : ℤ) → (exponent : ℕ) → motive { mantissa := mantissa, exponent := exponent }) → motive t | null | false |
IsZGroup.instQuotientSubgroupOfFinite | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ {G : Type u_1} [inst : Group G] [Finite G] [IsZGroup G] (H : Subgroup G) [inst_3 : H.Normal], IsZGroup (G ⧸ H) | null | true |
CartanMatrix.C | Mathlib.LinearAlgebra.Matrix.Cartan.Basic | (n : ℕ) → Matrix (Fin n) (Fin n) ℤ | The Cartan matrix of type Cₙ (rank n, corresponding to sp(2n)). | true |
NumberField.instCommRingInfiniteAdeleRing._aux_34 | Mathlib.NumberTheory.NumberField.InfiniteAdeleRing | (K : Type u_1) → [inst : Field K] → ℤ → NumberField.InfiniteAdeleRing K → NumberField.InfiniteAdeleRing K | null | false |
Set.disjoint_image_inl_image_inr | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {u : Set α} {v : Set β}, Disjoint (Sum.inl '' u) (Sum.inr '' v) | null | true |
Int8.not_xor | Init.Data.SInt.Bitwise | ∀ {a b : Int8}, ~~~a ^^^ b = ~~~(a ^^^ b) | null | true |
StrictConvexOn.strictMonoOn_derivWithin | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ}, StrictConvexOn ℝ S f → DifferentiableOn ℝ f S → StrictMonoOn (derivWithin f S) S | If `f` is convex on `S` and differentiable on `S`, then its derivative within `S` is monotone
on `S`. | true |
Lean.LeanOptionValue._sizeOf_inst | Lean.Util.LeanOptions | SizeOf Lean.LeanOptionValue | null | false |
CategoryTheory.AddMon.trivial_addMon_zero | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.AddMonObj.zero = CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) | null | true |
CategoryTheory.Bicategory.InducedBicategory.Hom₂.casesOn | 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} →
{motive : CategoryTheory.Bicategory.InducedBicategory.Hom₂ f g → Sort u} →
(t : CategoryTheory.Bicatego... | null | false |
Std.HashMap.Raw.valuesIter | Std.Data.HashMap.Iterator | {α β : Type u} → Std.HashMap.Raw α β → Std.Iter β | Returns a finite iterator over the values of a hash map.
The iterator yields the values in order and then terminates.
The key and value types must live in the same universe.
**Termination properties:**
* `Finite` instance: always
* `Productive` instance: always
| true |
CategoryTheory.ObjectProperty.extensionProductIter_le_of_isTriangulatedClosed₂' | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryT... | null | true |
Dioph.«term_D*_» | Mathlib.NumberTheory.Dioph | Lean.TrailingParserDescr | Diophantine functions are closed under multiplication. | true |
Turing.ToPartrec.Code.brecOn.eq | Mathlib.Computability.TuringMachine.Config | ∀ {motive : Turing.ToPartrec.Code → Sort u} (t : Turing.ToPartrec.Code)
(F_1 : (t : Turing.ToPartrec.Code) → Turing.ToPartrec.Code.below t → motive t),
Turing.ToPartrec.Code.brecOn t F_1 = F_1 t (Turing.ToPartrec.Code.brecOn.go t F_1).2 | null | true |
_private.Mathlib.Topology.Algebra.ValuativeRel.Completion.0.Valuation.inversion_estimate._simp_1_1 | Mathlib.Topology.Algebra.ValuativeRel.Completion | ∀ {G₀ : Type u_3} {G₀' : Type u_5} {F : Type u_6} [inst : GroupWithZero G₀] [inst_1 : GroupWithZero G₀']
[inst_2 : FunLike F G₀ G₀'] [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (a : G₀), (f a)⁻¹ = f a⁻¹ | null | false |
RootPairing.reflectionPerm_root | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : 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] (self : RootPairing ι R M N) (i j : ι),
self.root j - (self.toLinearMap (self.root j)) (self.coroot i) • self.root i = self.root ((self.re... | null | true |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocFrame.mk.noConfusion | Lean.DocString.Extension | {P : Sort u} →
{content : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock)} →
{priorParts : Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty)} →
{titleString : String} →
{title : Array (Lean.Doc.Inline Lean.ElabInline)} →
{content' : Array (Lean.Doc.Block Lean.ElabInline Lean... | null | false |
Std.DTreeMap.Internal.Impl.link.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (r : Std.DTreeMap.Internal.Impl α β) (hr : r.Balanced)
(hr_2 : Std.DTreeMap.Internal.Impl.leaf.Balanced),
Std.DTreeMap.Internal.Impl.link k v Std.DTreeMap.Internal.Impl.leaf r hr_2 hr =
{ impl := (Std.DTreeMap.Internal.Impl.insertMin k v r ⋯).impl, balanced_impl... | null | true |
CategoryTheory.cechNerveTerminalFrom._proof_1 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Limits.HasFiniteProducts C] (X : C)
(n : SimplexCategoryᵒᵖ), CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor fun x => X) | null | false |
Module.Relations.instQuotient | Mathlib.Algebra.Module.Presentation.Basic | {A : Type u_1} → [inst : Ring A] → (relations : Module.Relations A) → Module A relations.Quotient | null | true |
CategoryTheory.Pseudofunctor.DescentData.pullFunctorObjHom_eq._proof_17 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_4} {S : C} {X : ι → C}
{f : (i : ι) → X i ⟶ S} {S' : C} {p : S' ⟶ S} {ι' : Type u_3} {X' : ι' → C} {f' : (j : ι') → X' j ⟶ S'} {α : ι' → ι}
{p' : (j : ι') → X' j ⟶ X (α j)},
(∀ (j : ι'), CategoryTheory.CategoryStruct.comp (p' j) (f (α j)) ... | null | false |
PresheafOfModules.ModuleColimit.ιM_jointly_surjective | Mathlib.Algebra.Category.ModuleCat.Presheaf.ColimitFunctor | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.LocallySmall.{w, v, u} C]
[CategoryTheory.IsCofiltered C] [CategoryTheory.InitiallySmall C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{cR : CategoryTheory.Limits.Cocone R} {hcR : CategoryTheory.Limits.IsColimit cR} {M : PresheafOfModules R}
{... | null | true |
NegPart.mk._flat_ctor | Mathlib.Algebra.Notation | {α : Type u_1} → (α → α) → NegPart α | null | false |
MulDistribMulActionHom.map_one' | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {A : Type u_4} [inst_2 : Monoid A]
[inst_3 : MulDistribMulAction M A] {B : Type u_5} [inst_4 : Monoid B] [inst_5 : MulDistribMulAction N B]
(self : A →ₑ*[φ] B), self.toFun 1 = 1 | The proposition that the function preserves 1 | true |
Orientation.oangle_sign_neg_right | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V), (o.oangle x (-y)).sign = -(o.oangle x y).sign | Negating the second vector passed to `oangle` negates the sign of the angle. | true |
derangements.Equiv.RemoveNone.fiber | Mathlib.Combinatorics.Derangements.Basic | {α : Type u_1} → [DecidableEq α] → Option α → Set (Equiv.Perm α) | The set of permutations `f` such that the preimage of `(a, f)` under
`Equiv.Perm.decomposeOption` is a derangement. | true |
ENNReal.toEReal_ofNat | Mathlib.Data.EReal.Basic | ∀ (n : ℕ) [inst : n.AtLeastTwo], ↑(OfNat.ofNat n) = OfNat.ofNat n | null | true |
dist_neg | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedAddCommGroup E] (x y : E), dist (-x) y = dist x (-y) | null | true |
CategoryTheory.SimplicialObject | Mathlib.AlgebraicTopology.SimplicialObject.Basic | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Type (max v u) | The category of simplicial objects valued in a category `C`.
This is the category of contravariant functors from `SimplexCategory` to `C`. | true |
CategoryTheory.Limits.BinaryCofan.ext.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryFan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B : C} {c c' : CategoryTheory.Limits.BinaryCofan A B}
(e : c.pt ≅ c'.pt) (h₁ : c.inl = CategoryTheory.CategoryStruct.comp c'.inl e.inv)
(h₂ : c.inr = CategoryTheory.CategoryStruct.comp c'.inr e.inv),
CategoryTheory.Limits.BinaryCofan.ext e h₁ h₂ = Catego... | null | true |
LinearIsometryEquiv.toContinuousLinearEquiv | Mathlib.Analysis.Normed.Operator.LinearIsometry | {R : Type u_1} →
{R₂ : Type u_2} →
{E : Type u_4} →
{E₂ : Type u_5} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
{σ₁₂ : R →+* R₂} →
{σ₂₁ : R₂ →+* R} →
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] →
[inst_3 : RingHomInvPair σ₂₁ σ₁₂] →
... | Interpret a `LinearIsometryEquiv` as a `ContinuousLinearEquiv`. | true |
sum_chartAt_inr_apply | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {H : Type u} {M : Type u_2} {M' : Type u_3} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M]
[inst_2 : TopologicalSpace M'] [cm : ChartedSpace H M] [cm' : ChartedSpace H M'] {x y : M'},
↑(chartAt H (Sum.inr x)) (Sum.inr y) = ↑(chartAt H x) y | null | true |
IsRadical.dvd_radical | Mathlib.RingTheory.Radical.Basic | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
{a : M}, IsRadical a → a ≠ 0 → a ∣ UniqueFactorizationMonoid.radical a | If `a` is a radical element, then it divides its radical. | true |
_private.Batteries.Data.Fin.Lemmas.0.Fin.findSomeRev?_eq_some_iff.match_1_1 | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {α : Type u_1} {a : α} {f : Fin n → Option α}
(motive : (∃ i, f i.rev = some a ∧ ∀ j < i, f j.rev = none) → Prop)
(x : ∃ i, f i.rev = some a ∧ ∀ j < i, f j.rev = none),
(∀ (i : Fin n) (h : f i.rev = some a ∧ ∀ j < i, f j.rev = none), motive ⋯) → motive x | null | false |
Pi.nonAssocSemiring._proof_1 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → NonAssocSemiring (f i)] (a : (i : I) → f i), 1 * a = a | null | false |
CategoryTheory.ObjectProperty.IsClosedUnderQuotients.prop_of_epi | Mathlib.CategoryTheory.ObjectProperty.EpiMono | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {P : CategoryTheory.ObjectProperty C}
[self : P.IsClosedUnderQuotients] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Epi f], P X → P Y | null | true |
Hypergraph.IsNonempty.of_nonempty_vertexSet | Mathlib.Combinatorics.Hypergraph.Basic | ∀ {α : Type u_1} {H : Hypergraph α}, H.vertexSet.Nonempty → H.IsNonempty | null | true |
CategoryTheory.Regular.regularEpiIsStableUnderBaseChange | Mathlib.CategoryTheory.RegularCategory.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.Regular C],
(CategoryTheory.MorphismProperty.regularEpi C).IsStableUnderBaseChange | null | true |
Lean.Elab.Command.instMonadMacroAdapterCommandElabM | Lean.Elab.Command | Lean.Elab.MonadMacroAdapter Lean.Elab.Command.CommandElabM | null | true |
_private.Mathlib.Algebra.Order.Group.Indicator.0.Function.mulSupport_iSup._simp_1_3 | Mathlib.Algebra.Order.Group.Indicator | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
Std.Sat.AIG.RelabelNat.State.Inv2.below.gate | Std.Sat.AIG.RelabelNat | ∀ {α : Type} [inst : DecidableEq α] [inst_1 : Hashable α] {decls : Array (Std.Sat.AIG.Decl α)}
{motive : (a : ℕ) → (a_1 : Std.HashMap α ℕ) → Std.Sat.AIG.RelabelNat.State.Inv2 decls a a_1 → Prop} {idx : ℕ}
{map : Std.HashMap α ℕ} {l r : Std.Sat.AIG.Fanin} (hinv : Std.Sat.AIG.RelabelNat.State.Inv2 decls idx map)
(h... | null | true |
Fin.insertNth_mul | Mathlib.Algebra.Group.Fin.Tuple | ∀ {n : ℕ} {α : Fin (n + 1) → Type u_1} [inst : (j : Fin (n + 1)) → Mul (α j)] (i : Fin (n + 1)) (x y : α i)
(p q : (j : Fin n) → α (i.succAbove j)), i.insertNth (x * y) (p * q) = i.insertNth x p * i.insertNth y q | null | true |
SemiNormedGrp.explicitCokernelIso_hom_desc | Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels | ∀ {X Y Z : SemiNormedGrp} {f : X ⟶ Y} {g : Y ⟶ Z} (w : CategoryTheory.CategoryStruct.comp f g = 0),
CategoryTheory.CategoryStruct.comp (SemiNormedGrp.explicitCokernelIso f).hom
(CategoryTheory.Limits.cokernel.desc f g w) =
SemiNormedGrp.explicitCokernelDesc w | null | true |
Std.DHashMap.values | Std.Data.DHashMap.Basic | {α : Type u} → {x : BEq α} → {x_1 : Hashable α} → {β : Type v} → (Std.DHashMap α fun x => β) → List β | Returns a list of all values present in the hash map in some order. | true |
Set.Nonempty.image2 | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β},
s.Nonempty → t.Nonempty → (Set.image2 f s t).Nonempty | null | true |
_private.Init.Data.List.Basic.0.List.dropLast.match_1.splitter | Init.Data.List.Basic | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) →
(Unit → motive []) →
((head : α) → motive [head]) → ((a : α) → (as : List α) → (as = [] → False) → motive (a :: as)) → motive x | null | true |
ImportGraph.Lean.Import.instToFormatFormatErrors.match_11 | ImportGraph.Imports.Pretty | (motive : List Std.Format → Sort u_1) →
(xs : List Std.Format) →
(Unit → motive []) →
((x : Std.Format) → motive [x]) →
((x₀ x₁ : Std.Format) → motive [x₀, x₁]) →
((xs : List Std.Format) →
(head head_1 : Std.Format) →
(tail : List Std.Format) →
... | null | false |
_private.Mathlib.Lean.Elab.InfoTree.0.Lean.Elab.Info.getLCtx?.match_1 | Mathlib.Lean.Elab.InfoTree | (motive : Lean.Elab.Info → Sort u_1) →
(x : Lean.Elab.Info) →
((i : Lean.Elab.TacticInfo) → motive (Lean.Elab.Info.ofTacticInfo i)) →
((i : Lean.Elab.TermInfo) → motive (Lean.Elab.Info.ofTermInfo i)) →
((i : Lean.Elab.PartialTermInfo) → motive (Lean.Elab.Info.ofPartialTermInfo i)) →
((x : ... | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Deriv.0.Real.iter_deriv_rpow_const._proof_1_4 | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ (r : ℝ) (k : ℕ) (y : ℝ),
y ^ (r - ↑k - 1) = y ^ (r - (↑k + 1)) ∨ Polynomial.eval r (descPochhammer ℝ k) = 0 ∨ r - ↑k = 0 | null | false |
CategoryTheory.Pseudofunctor.Grothendieck.Hom.fiber | Mathlib.CategoryTheory.Bicategory.Grothendieck | {𝒮 : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} →
{X Y : F.Grothendieck} → (self : X.Hom Y) → (F.map self.base.toLoc).toFunctor.obj X.fiber ⟶ Y.fiber | The morphism in the fiber over the domain. | true |
Set.ordConnected_pi' | Mathlib.Order.Interval.Set.OrdConnected | ∀ {ι : Type u_3} {α : ι → Type u_4} [inst : (i : ι) → Preorder (α i)] {s : Set ι} {t : (i : ι) → Set (α i)}
[h : ∀ (i : ι), (t i).OrdConnected], (s.pi t).OrdConnected | null | true |
CategoryTheory.MorphismProperty.LeftFraction.noConfusionType | Mathlib.CategoryTheory.Localization.CalculusOfFractions | Sort u →
{C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
{X Y : C} →
W.LeftFraction X Y →
{C' : Type u_1} →
[inst' : CategoryTheory.Category.{v_1, u_1} C'] →
{W' : CategoryTheory.MorphismPr... | null | false |
CategoryTheory.ChosenPullbacksAlong.binaryFanIsBinaryProduct._proof_4 | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (Y Z : CategoryTheory.Over X)
[inst_1 : CategoryTheory.ChosenPullbacksAlong Z.hom] {T : CategoryTheory.Over X} (f : T ⟶ Y) (g : T ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.homMk
(CategoryTheory.ChosenPullbacksAl... | null | false |
SimpleGraph.neighborSet_ne_univ | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (G : SimpleGraph V) (v : V), G.neighborSet v ≠ Set.univ | null | true |
AddSubmonoid.le_toAddSubmonoid_saturation | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : AddZeroClass M] {a : AddSubmonoid M}, a ≤ a.saturation.toAddSubmonoid | null | true |
LeftOrdContinuous.rightOrdContinuous_dual | Mathlib.Order.OrdContinuous | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
LeftOrdContinuous f → RightOrdContinuous (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) | **Alias** of `LeftOrdContinuous.dual`. | true |
Lean.Grind.CommRing.Poly.denote_combineC | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} {c : ℕ} [inst : Lean.Grind.Ring α] [Lean.Grind.IsCharP α c] (ctx : Lean.Grind.CommRing.Context α)
(p₁ p₂ : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.denote ctx (p₁.combineC p₂ c) =
Lean.Grind.CommRing.Poly.denote ctx p₁ + Lean.Grind.CommRing.Poly.denote ctx p₂ | null | true |
HahnEmbedding.Seed.rec | Mathlib.Algebra.Order.Module.HahnEmbedding | {K : Type u_1} →
[inst : DivisionRing K] →
[inst_1 : LinearOrder K] →
[inst_2 : IsOrderedRing K] →
[inst_3 : Archimedean K] →
{M : Type u_2} →
[inst_4 : AddCommGroup M] →
[inst_5 : LinearOrder M] →
[inst_6 : IsOrderedAddMonoid M] →
... | null | false |
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.rewriteOneFile.match_1 | Mathlib.Tactic.Linter.FindDeprecations | (motive : Lean.Name × Lean.Syntax.Range → Sort u_1) →
(x : Lean.Name × Lean.Syntax.Range) →
((decl : Lean.Name) → (s e : String.Pos.Raw) → motive (decl, { start := s, stop := e })) → motive x | null | false |
Lean.Parser.Command.versoCommentBody.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
Std.TreeMap.Raw.getElem?_diff_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₁ → (t₁ \ t₂)[k]? = none | null | true |
Std.HashMap.insertMany_ind | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {ρ : Type w} [inst : ForIn Id ρ (α × β)]
{motive : Std.HashMap α β → Prop} (m : Std.HashMap α β) {l : ρ},
motive m → (∀ (m : Std.HashMap α β) (a : α) (b : β), motive m → motive (m.insert a b)) → motive (m.insertMany l) | null | true |
Std.ExtTreeMap.minEntry.match_1 | Std.Data.ExtTreeMap.Basic | ∀ {α : Type u_1} {β : Type u_2} {cmp : α → α → Ordering}
(motive : (t : Std.ExtTreeMap α β cmp) → t ≠ ∅ → t.inner = ∅ → Prop) (t : Std.ExtTreeMap α β cmp) (h : t ≠ ∅)
(x : t.inner = ∅), motive t h x | null | false |
Finsupp.domCongr_apply | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] (e : α ≃ β) (l : α →₀ M),
(Finsupp.domCongr e) l = Finsupp.equivMapDomain e l | null | true |
String.Slice.toInt?_eq_toNat?_of_startsWith_eq_false | Std.Data.String.ToInt | ∀ {s : String.Slice}, s.startsWith '-' = false → s.toInt? = Option.map (fun n => ↑n) s.toNat? | null | true |
_private.Mathlib.Order.Filter.Map.0.Filter.comap_neBot_iff._simp_1_2 | Mathlib.Order.Filter.Map | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
RootPairing.EmbeddedG2.shortAddLong.eq_1 | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : 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)
[inst_5 : P.EmbeddedG2],
RootPairing.EmbeddedG2.shortAddLong P =
(P.reflectionPerm (RootPairing.EmbeddedG2... | null | true |
instMinNat | Init.Prelude | Min ℕ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.