name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
DividedPowers.Quotient.isDPMorphism | Mathlib.RingTheory.DividedPowers.SubDPIdeal | ∀ {A : Type u_1} [inst : CommRing A] {I : Ideal A} (hI : DividedPowers I) {J : Ideal A} (hIJ : hI.IsSubDPIdeal (J ⊓ I)),
hI.IsDPMorphism (DividedPowers.Quotient.dividedPowers hI hIJ) (Ideal.Quotient.mk J) | true |
_private.Mathlib.Analysis.Calculus.LHopital.0.HasDerivAt.lhopital_zero_left_on_Ioo._proof_1_1 | Mathlib.Analysis.Calculus.LHopital | ContinuousSMul ℝ ℝ | false |
Finset.union_div | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Div α] {s₁ s₂ t : Finset α}, (s₁ ∪ s₂) / t = s₁ / t ∪ s₂ / t | true |
Lean.Grind.Semiring | Init.Grind.Ring.Basic | Type u → Type u | true |
_private.Mathlib.Topology.Semicontinuity.Basic.0.continuousAt_iff_lower_upperSemicontinuousAt._simp_1_3 | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : Preorder β] {f : α → β} {x : α},
UpperSemicontinuousAt f x = UpperSemicontinuousWithinAt f Set.univ x | false |
NormedAddGroupHom.norm_incl | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} [inst : SeminormedAddCommGroup V] {V' : AddSubgroup V} (x : ↥V'), ‖(NormedAddGroupHom.incl V') x‖ = ‖x‖ | true |
_private.Init.Data.UInt.Bitwise.0.UInt16.right_le_or._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt16}, (a ≤ b) = (a.toNat ≤ b.toNat) | false |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Presentation.Expr.4203983209._hygCtx._hyg.1.rec | ProofWidgets.Presentation.Expr | {motive : ProofWidgets.RpcEncodablePacket✝ → Sort u} →
((expr name : Lean.Json) → motive { expr := expr, name := name }) → (t : ProofWidgets.RpcEncodablePacket✝) → motive t | false |
ENat.floor_lt | Mathlib.Algebra.Order.Floor.Extended | ∀ {r : ENNReal} {n : ℕ∞}, ⌊r⌋ₑ < n ↔ r < ↑n | true |
Lean.Meta.Sym.instantiateRevRangeS | Lean.Meta.Sym.InstantiateS | Lean.Expr → ℕ → ℕ → Array Lean.Expr → Lean.Meta.Sym.SymM Lean.Expr | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema.0.Polynomial.Chebyshev.roots_U_real._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema | ∀ (n k : ℕ), k ∈ Finset.range n → k + 1 < n + 1 | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric.0.IsometricContinuousFunctionalCalculus.toNonUnital._simp_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, CompactSpace ↑s = IsCompact s | false |
_private.Mathlib.Combinatorics.SimpleGraph.Matching.0.SimpleGraph.Subgraph.IsPerfectMatching.symmDiff_isCycles._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Matching | ∀ {a b : Prop}, (a → b) = (¬a ∨ b) | false |
Algebra.Presentation.algebraTensorAlgEquiv_symm_relation | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] {P : Algebra.Presentation R S ι σ} (R₀ : Type u_5) [inst_3 : CommRing R₀]
[inst_4 : Algebra R₀ R] [inst_5 : Algebra R₀ S] [inst_6 : IsScalarTower R₀ R S] [inst_7 : P.HasCoeffs R₀] (r : σ),
... | true |
_private.Batteries.Data.BinaryHeap.Basic.0.Batteries.BinaryHeap.heapifyDown._unary.eq_def | Batteries.Data.BinaryHeap.Basic | ∀ {α : Type u_1} {sz : ℕ} (lt : α → α → Bool) (_x : (_ : Vector α sz) ×' Fin sz),
Batteries.BinaryHeap.heapifyDown._unary lt _x =
PSigma.casesOn _x fun a i =>
match h : Batteries.BinaryHeap.maxChild✝ lt a i with
| none => a
| some j =>
have this := ⋯;
if lt a[i] a[j] = true then ... | false |
BitVec.ofNat_sub_ofNat | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (x y : ℕ), BitVec.ofNat n x - BitVec.ofNat n y = BitVec.ofNat n (2 ^ n - y % 2 ^ n + x) | true |
AbstractSimplicialComplex.instMin | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | {ι : Type u_1} → Min (AbstractSimplicialComplex ι) | true |
instIsTransLt | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : Preorder α], IsTrans α fun x1 x2 => x1 < x2 | true |
le_add_of_le_left | Mathlib.Algebra.Order.Monoid.Canonical.Defs | ∀ {α : Type u} [inst : Add α] [inst_1 : Preorder α] [CanonicallyOrderedAdd α] {a b c : α}, a ≤ b → a ≤ b + c | true |
CategoryTheory.Simple.casesOn | Mathlib.CategoryTheory.Simple | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{X : C} →
{motive : CategoryTheory.Simple X → Sort u_1} →
(t : CategoryTheory.Simple X) →
((mono_isIso_iff_nonzero : ∀ {Y : C} (f : Y ⟶ X) [CategoryTheory.Mono f], C... | false |
CategoryTheory.Linear.homModuleOfRingMorphism | Mathlib.CategoryTheory.Center.Linear | {R : Type w} →
[inst : Ring R] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
[inst_2 : CategoryTheory.Preadditive C] → (R →+* CategoryTheory.CatCenter C) → (X Y : C) → Module R (X ⟶ Y) | true |
Monoid.PushoutI.NormalWord.equivPair | Mathlib.GroupTheory.PushoutI | {ι : Type u_1} →
{G : ι → Type u_2} →
{H : Type u_3} →
[inst : (i : ι) → Group (G i)] →
[inst_1 : Group H] →
{φ : (i : ι) → H →* G i} →
{d : Monoid.PushoutI.NormalWord.Transversal φ} →
[DecidableEq ι] →
[(i : ι) → DecidableEq (G i)] →
... | true |
_private.Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid.0.Affine.Simplex.eq_centroid_of_forall_mem_median._proof_1_10 | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {k : Type u_3} {V : Type u_1} {P : Type u_2} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {n : ℕ} (s : Affine.Simplex k P n),
(fun i => s.points ↑i -ᵥ s.centroid) =
(fun i =>
(if ↑i = 0 then Finset.centroid k Finset.univ s.points else s.points ↑i) -ᵥ... | false |
CFC.toLinearMap_conjSqrt | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.ConjSqrt | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] [inst_8 : SeparatelyContinuousMul A] (c : A),
↑(CFC.conjSq... | true |
Lean.Parser.Term.prop._regBuiltin.Lean.Parser.Term.prop.formatter_9 | Lean.Parser.Term | IO Unit | false |
Complex.log_I | Mathlib.Analysis.SpecialFunctions.Complex.Log | Complex.log Complex.I = ↑Real.pi / 2 * Complex.I | true |
Set.disjoint_diagonal_offDiag | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} (s : Set α), Disjoint (Set.diagonal α) s.offDiag | true |
CompHausLike.finiteCoproduct.isColimit._proof_1 | Mathlib.Topology.Category.CompHausLike.Limits | ∀ {P : TopCat → Prop} {α : Type u_1} [inst : Finite α] (X : α → CompHausLike P)
[inst_1 : CompHausLike.HasExplicitFiniteCoproduct X] (x : CategoryTheory.Limits.Cofan X) (x_1 : α),
CategoryTheory.CategoryStruct.comp (CompHausLike.finiteCoproduct.ι X { as := x_1 }.as)
(CompHausLike.finiteCoproduct.desc X fun a ... | false |
_private.Mathlib.MeasureTheory.Constructions.BorelSpace.Order.0.Dense.borel_eq_generateFrom_Ico_mem_aux._simp_1_4 | Mathlib.MeasureTheory.Constructions.BorelSpace.Order | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
CategoryTheory.NatTrans.rightDerived_comp_assoc | Mathlib.CategoryTheory.Abelian.RightDerived | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.HasInjectiveResolutions C]
[inst_4 : CategoryTheory.Abelian D] {F G H : CategoryTheory.Functor C D} [inst_5 : F.Additive] [inst_6 : G.A... | true |
BoolRing.carrier | Mathlib.Algebra.Category.BoolRing | BoolRing → Type u | true |
Function.star_sumElim | Mathlib.Algebra.Star.Pi | ∀ {I : Type u_1} {J : Type u_2} {α : Type u_3} (x : I → α) (y : J → α) [inst : Star α],
star (Sum.elim x y) = Sum.elim (star x) (star y) | true |
List.foldrM_wfParam | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] [LawfulMonad m] {xs : List α}
{f : α → β → m β} {init : β}, List.foldrM f init (wfParam xs) = List.foldrM f init xs.attach.unattach | true |
Finsupp.tail_apply | Mathlib.Data.Finsupp.Fin | ∀ {n : ℕ} (i : Fin n) {M : Type u_1} [inst : Zero M] (t : Fin (n + 1) →₀ M), t.tail i = t i.succ | true |
BooleanAlgebra.toBooleanRing._proof_11 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanAlgebra α] (a : α), a * 0 = 0 | false |
Lean.Meta.RewriteResult._sizeOf_1 | Lean.Meta.Tactic.Rewrite | Lean.Meta.RewriteResult → ℕ | false |
LeftInvariantDerivation.ext_iff | Mathlib.Geometry.Manifold.Algebra.LeftInvariantDerivation | ∀ {𝕜 : 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} {G : Type u_4}
[inst_4 : TopologicalSpace G] [inst_5 : ChartedSpace H G] [inst_6 : Monoid G] [inst_7 : ContMDiff... | true |
Finpartition.indiscrete | Mathlib.Order.Partition.Finpartition | {α : Type u_1} → [inst : Lattice α] → [inst_1 : OrderBot α] → {a : α} → a ≠ ⊥ → Finpartition a | true |
Lean.Lsp.ResolvableCompletionItem.mk.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | ∀ (label : String) (detail? : Option String) (documentation? : Option Lean.Lsp.MarkupContent)
(kind? : Option Lean.Lsp.CompletionItemKind) (textEdit? : Option Lean.Lsp.InsertReplaceEdit)
(sortText? : Option String) (data? : Option Lean.Lsp.ResolvableCompletionItemData)
(tags? : Option (Array Lean.Lsp.CompletionIt... | true |
LinearMap.instSMulDomMulAct | Mathlib.Algebra.Module.LinearMap.Basic | {R : Type u_1} →
{R' : Type u_2} →
{M : Type u_4} →
{M' : Type u_5} →
[inst : Semiring R] →
[inst_1 : Semiring R'] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M'] →
[inst_4 : Module R M] →
[inst_5 : Module R' M'] →
... | true |
Lean.Meta.Grind.ParentSet.ctorIdx | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.ParentSet → ℕ | false |
CategoryTheory.ChosenPullbacksAlong.pullbackIsoOverPullback_inv_app_comp_snd | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Z X : C} (g : Z ⟶ X)
[inst_1 : CategoryTheory.ChosenPullbacksAlong g] (T : CategoryTheory.Over X),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.ChosenPullbacksAlong.pullbackIsoOverPullback g).inv.app T).left
(CategoryTheory.ChosenPullbacksAlo... | true |
not_forall_not | Mathlib.Logic.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), ¬p x) ↔ ∃ x, p x | true |
Array.iterFromIdxM_equiv_iterM_drop_toList | Std.Data.Iterators.Lemmas.Producers.Monadic.Array | ∀ {α : Type w} {array : Array α} {m : Type w → Type w'} [inst : Monad m] [inst_1 : LawfulMonad m] {pos : ℕ},
(array.iterFromIdxM m pos).Equiv ((List.drop pos array.toList).iterM m) | true |
Bornology.rec | Mathlib.Topology.Bornology.Basic | {α : Type u_4} →
{motive : Bornology α → Sort u} →
((cobounded : Filter α) →
(le_cofinite : cobounded ≤ Filter.cofinite) → motive { cobounded := cobounded, le_cofinite := le_cofinite }) →
(t : Bornology α) → motive t | false |
SlashInvariantForm.recOn | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | {Γ : Subgroup (GL (Fin 2) ℝ)} →
{k : ℤ} →
{motive : SlashInvariantForm Γ k → Sort u} →
(t : SlashInvariantForm Γ k) →
((toFun : UpperHalfPlane → ℂ) →
(slash_action_eq' : ∀ γ ∈ Γ, SlashAction.map k γ toFun = toFun) →
motive { toFun := toFun, slash_action_eq' := slash_action_... | false |
MeasureTheory.IsAddFundamentalDomain.setIntegral_eq_tsum | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} {E : Type u_5} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α]
[inst_3 : NormedAddCommGroup E] {s : Set α} {μ : MeasureTheory.Measure α} [MeasurableConstVAdd G α]
[MeasureTheory.VAddInvariantMeasure G α μ] [Countable G] [inst_7 : NormedSpace ℝ E],
MeasureT... | true |
Sym2.fromRel_mono | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {r₁ r₂ : α → α → Prop} (sym₁ : Symmetric r₁) (sym₂ : Symmetric r₂),
r₁ ≤ r₂ → Sym2.fromRel sym₁ ⊆ Sym2.fromRel sym₂ | true |
EuclideanGeometry.oangle_add_swap | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p p₁ p₂ p₃ : P},
p₁ ≠ p →
p₂ ≠ p →
p₃ ≠ p → EuclideanGeometry.oangle p₂ p p... | true |
List.splitWrtCompositionAux.match_1 | Mathlib.Combinatorics.Enumerative.Composition | {α : Type u_1} →
(motive : List α × List α → Sort u_2) → (x : List α × List α) → ((l₁ l₂ : List α) → motive (l₁, l₂)) → motive x | false |
_private.Lean.Elab.Tactic.Grind.Param.0.Lean.Elab.Tactic.addEMatchTheorem.match_7 | Lean.Elab.Tactic.Grind.Param | (motive : Option (Array Lean.Meta.Grind.EMatchTheorem) → Sort u_1) →
(__x : Option (Array Lean.Meta.Grind.EMatchTheorem)) →
((thms : Array Lean.Meta.Grind.EMatchTheorem) → motive (some thms)) →
((x : Option (Array Lean.Meta.Grind.EMatchTheorem)) → motive x) → motive __x | false |
Finsupp.addSingleEquiv._proof_2 | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {R : Type u_1} [inst : Ring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | false |
Mathlib.Meta.Nat.UnifyZeroOrSuccResult.noConfusionType | Mathlib.Tactic.NormNum.BigOperators | Sort u →
{n : Q(ℕ)} →
Mathlib.Meta.Nat.UnifyZeroOrSuccResult n → {n' : Q(ℕ)} → Mathlib.Meta.Nat.UnifyZeroOrSuccResult n' → Sort u | false |
Ideal.comap_eq_top_iff._simp_1 | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] {f : F}
[inst_3 : RingHomClass F R S] {I : Ideal S}, (Ideal.comap f I = ⊤) = (I = ⊤) | false |
MeasurableSpace.measurableSet_sSup | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} {ms : Set (MeasurableSpace α)} {s : Set α},
MeasurableSet s ↔ MeasurableSpace.GenerateMeasurable {s | ∃ m ∈ ms, MeasurableSet s} s | true |
AddChar.coe_sum._simp_1 | Mathlib.Algebra.Group.AddChar | ∀ {ι : Type u_1} {A : Type u_2} {M : Type u_3} [inst : AddMonoid A] [inst_1 : CommMonoid M] (s : Finset ι)
(ψ : ι → AddChar A M), ∏ i ∈ s, ⇑(ψ i) = ⇑(∑ i ∈ s, ψ i) | false |
List.drop_eq_nil_of_le | Init.Data.List.Basic | ∀ {α : Type u} {as : List α} {i : ℕ}, as.length ≤ i → List.drop i as = [] | true |
Subalgebra.toCommSemiring | Mathlib.Algebra.Algebra.Subalgebra.Basic | {R : Type u_1} →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring A] → [inst_2 : Algebra R A] → (S : Subalgebra R A) → CommSemiring ↥S | true |
Lean.Widget.inst._@.Lean.Widget.Basic.2318528980._hygCtx._hyg.3 | Lean.Widget.Basic | TypeName Lean.Elab.ContextInfo | false |
SSet.modelCategoryQuillen.mono_of_cofibration | Mathlib.AlgebraicTopology.SimplicialSet.CategoryWithFibrations | ∀ {X Y : SSet} (f : X ⟶ Y) [HomotopicalAlgebra.Cofibration f], CategoryTheory.Mono f | true |
Std.HashMap.Equiv.insertManyIfNewUnit_list | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] {m₁ m₂ : Std.HashMap α Unit} (l : List α),
m₁.Equiv m₂ → (m₁.insertManyIfNewUnit l).Equiv (m₂.insertManyIfNewUnit l) | true |
EuclideanDomain.mod_eq_sub_mul_div | Mathlib.Algebra.EuclideanDomain.Basic | ∀ {R : Type u_1} [inst : EuclideanDomain R] (a b : R), a % b = a - b * (a / b) | true |
_private.Mathlib.RingTheory.NormalClosure.0.Ring.termL | Mathlib.RingTheory.NormalClosure | Lean.ParserDescr | true |
StarSubalgebra.topologicalClosure_map_le | Mathlib.Topology.Algebra.StarSubalgebra | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : StarRing A]
[inst_6 : StarModule R A] [inst_7 : IsSemitopologicalSemiring A] [inst_8 : ContinuousStar A]
[inst_9 : TopologicalSpace B] [... | true |
CategoryTheory.MonoidalCategory.DayConvolution.corepresentableBy_homEquiv_apply_app | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalCategory V]
(F G : CategoryTheory.Functor C V) [inst_4 : CategoryTheory.MonoidalCategory.DayConvolution F G]
{Y : Ca... | true |
CategoryTheory.Limits.Fork.IsLimit.mk._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f g : X ⟶ Y}
(t : CategoryTheory.Limits.Fork f g) (lift : (s : CategoryTheory.Limits.Fork f g) → s.pt ⟶ t.pt),
(∀ (s : CategoryTheory.Limits.Fork f g), CategoryTheory.CategoryStruct.comp (lift s) t.ι = s.ι) →
∀ (s : CategoryTheory.Limits.... | false |
MultilinearMap.instSMul | Mathlib.LinearAlgebra.Multilinear.Basic | {R : Type uR} →
{S : Type uS} →
{ι : Type uι} →
{M₁ : ι → Type v₁} →
{M₂ : Type v₂} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : (i : ι) → Module R (M₁ i)] →
[inst_4 :... | true |
Array.mapFinIdx_induction | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} (xs : Array α) (f : (i : ℕ) → α → i < xs.size → β) (motive : ℕ → Prop),
motive 0 →
∀ (p : (i : ℕ) → β → i < xs.size → Prop),
(∀ (i : ℕ) (h : i < xs.size), motive i → p i (f i xs[i] h) h ∧ motive (i + 1)) →
motive xs.size ∧
∃ (eq : (xs.mapFinIdx f).size = xs.... | true |
Lean.Grind.Linarith.Poly.insert.induct_unfolding | Init.Grind.Ordered.Linarith | ∀ (k : ℤ) (v : Lean.Grind.Linarith.Var) (motive : Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Poly → Prop),
motive Lean.Grind.Linarith.Poly.nil (Lean.Grind.Linarith.Poly.add k v Lean.Grind.Linarith.Poly.nil) →
(∀ (k_1 : ℤ) (v_1 : Lean.Grind.Linarith.Var) (p : Lean.Grind.Linarith.Poly),
Nat.blt v_1 v = ... | true |
AbsoluteValue.isEquiv_trivial_iff_eq_trivial._simp_1 | Mathlib.Analysis.AbsoluteValue.Equivalence | ∀ {R : Type u_1} {S : Type u_2} [inst : Field R] [inst_1 : Semifield S] [inst_2 : LinearOrder S]
[inst_3 : DecidablePred fun x => x = 0] [inst_4 : NoZeroDivisors R] [inst_5 : IsStrictOrderedRing S]
{f : AbsoluteValue R S}, f.IsEquiv AbsoluteValue.trivial = (f = AbsoluteValue.trivial) | false |
Aesop.Rapp.runMetaM' | Aesop.Tree.RunMetaM | {m : Type → Type u_1} → [Monad m] → [MonadLiftT Lean.MetaM m] → [MonadFinally m] → {α : Type} → m α → Aesop.Rapp → m α | true |
Finpartition.nonuniformWitness_mem_nonuniformWitnesses | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : IsStrictOrderedRing 𝕜]
[inst_3 : DecidableEq α] {A : Finset α} {P : Finpartition A} {G : SimpleGraph α} [inst_4 : DecidableRel G.Adj] {ε : 𝕜}
{s t : Finset α}, ¬G.IsUniform ε s t → t ∈ P.parts → s ≠ t → G.nonuniformWitness ε s ... | true |
ContinuousAlternatingMap.toAlternatingMap_add | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] [inst_7 : ContinuousAdd N] (f g : M [⋀^ι]→L[R] N),
(f + g).toAlternatingMa... | true |
Matroid.Dep.eRk_lt_encard | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} {M : Matroid α} {X : Set α} [M.RankFinite], M.Dep X → M.eRk X < X.encard | true |
ValuativeRel.mul_rel_mul_iff_right | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] {x y z : R}, 0 <ᵥ x → (x * y ≤ᵥ x * z ↔ y ≤ᵥ z) | true |
Filter.smul_filter.instNeBot | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {f : Filter β} {a : α} [f.NeBot], (a • f).NeBot | true |
_private.Mathlib.ModelTheory.Equivalence.0.FirstOrder.Language.Theory.bot_imp._simp_1_1 | Mathlib.ModelTheory.Equivalence | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {φ ψ : L.BoundedFormula α l}
{v : α → M} {xs : Fin l → M}, (φ.imp ψ).Realize v xs = (φ.Realize v xs → ψ.Realize v xs) | false |
Matroid.ofExistsFiniteIsBase | Mathlib.Combinatorics.Matroid.IndepAxioms | {α : Type u_1} →
(E : Set α) →
(IsBase : Set α → Prop) →
(∃ B, IsBase B ∧ B.Finite) → Matroid.ExchangeProperty IsBase → (∀ (B : Set α), IsBase B → B ⊆ E) → Matroid α | true |
Congr!.plausiblyEqualTypes._sunfold | Mathlib.Tactic.CongrExclamation | Lean.Expr → Lean.Expr → optParam ℕ 5 → Lean.MetaM Bool | false |
AlgebraicGeometry.FormallyUnramified.stalkMap | Mathlib.AlgebraicGeometry.Morphisms.FormallyUnramified | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.FormallyUnramified f] (x : ↥X),
(CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.stalkMap f x)).FormallyUnramified | true |
Lean.Doc.Parser.UnorderedListType.dash | Lean.DocString.Parser | Lean.Doc.Parser.UnorderedListType | true |
CategoryTheory.MorphismProperty.Under.map.eq_1 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P : CategoryTheory.MorphismProperty T}
(Q : CategoryTheory.MorphismProperty T) [inst_1 : Q.IsMultiplicative] {X Y : T} [inst_2 : P.IsStableUnderComposition]
{f : X ⟶ Y} (hPf : P f),
CategoryTheory.MorphismProperty.Under.map Q hPf =
CategoryTheory... | true |
dense_biInter_of_isOpen | Mathlib.Topology.Baire.Lemmas | ∀ {X : Type u_1} {α : Type u_2} [inst : TopologicalSpace X] [BaireSpace X] {S : Set α} {f : α → Set X},
(∀ s ∈ S, IsOpen (f s)) → S.Countable → (∀ s ∈ S, Dense (f s)) → Dense (⋂ s ∈ S, f s) | true |
RatFunc.map | Mathlib.FieldTheory.RatFunc.Basic | {R : Type u_3} →
{S : Type u_4} →
{F : Type u_5} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : FunLike F (Polynomial R) (Polynomial S)] →
[inst_3 : MonoidHomClass F (Polynomial R) (Polynomial S)] →
(φ : F) →
nonZeroDivisors (Polynomial ... | true |
Finset.attach_image_val | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α}, Finset.image Subtype.val s.attach = s | true |
_private.Init.Data.String.Basic.0.String.Pos.ne_of_lt._simp_1_1 | Init.Data.String.Basic | ∀ {s : String} {l r : s.Pos}, (l < r) = (l.offset < r.offset) | false |
CauSeq.Completion.Cauchy.ring._proof_2 | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_1}
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv], CauSeq.Completion.mk 1 = 1 | false |
Lean.Widget.RpcEncodablePacket._sizeOf_1._@.Lean.Widget.InteractiveDiagnostic.2157017296._hygCtx._hyg.1 | Lean.Widget.InteractiveDiagnostic | Lean.Widget.RpcEncodablePacket✝ → ℕ | false |
Profinite.toTopCat.createsLimits | Mathlib.Topology.Category.Profinite.Basic | CategoryTheory.CreatesLimits Profinite.toTopCat | true |
AffineMap.id_apply | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ (k : Type u_1) {V1 : Type u_2} {P1 : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1]
[inst_3 : AddTorsor V1 P1] (p : P1), (AffineMap.id k P1) p = p | true |
MvPolynomial.expand_one | Mathlib.Algebra.MvPolynomial.Expand | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R], MvPolynomial.expand 1 = AlgHom.id R (MvPolynomial σ R) | true |
Finpartition.part.eq_1 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} (P : Finpartition s) (a : α),
P.part a = if ha : a ∈ s then Finset.choose (fun a_1 => a ∈ a_1) P.parts ⋯ else ∅ | true |
AlgebraicGeometry.Spec.locallyRingedSpaceObj_presheaf' | Mathlib.AlgebraicGeometry.Spec | ∀ (R : Type u) [inst : CommRing R],
(AlgebraicGeometry.Spec.locallyRingedSpaceObj (CommRingCat.of R)).presheaf =
(AlgebraicGeometry.Spec.structureSheaf R).obj | true |
ContinuousLinearMap.opNNNorm_eq_of_bounds | Mathlib.Analysis.Normed.Operator.NNNorm | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NontriviallyNormedField 𝕜₂] [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_6 : RingHomIsometric σ... | true |
DihedralGroup._sizeOf_inst | Mathlib.GroupTheory.SpecificGroups.Dihedral | (n : ℕ) → SizeOf (DihedralGroup n) | false |
SimpleGraph.nonuniformWitness_spec | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : IsStrictOrderedRing 𝕜]
(G : SimpleGraph α) [inst_3 : DecidableRel G.Adj] {ε : 𝕜} {s t : Finset α},
s ≠ t →
¬G.IsUniform ε s t →
ε ≤ ↑|G.edgeDensity (G.nonuniformWitness ε s t) (G.nonuniformWitness ε t s) - G.edgeDensi... | true |
AdicCompletion.AdicCauchySequence.mk | Mathlib.RingTheory.AdicCompletion.Basic | {R : Type u_1} →
[inst : CommRing R] →
(I : Ideal R) →
(M : Type u_4) →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
(f : ℕ → M) → (∀ (n : ℕ), f n ≡ f (n + 1) [SMOD I ^ n • ⊤]) → AdicCompletion.AdicCauchySequence I M | true |
_private.Mathlib.RingTheory.Flat.Basic.0.Module.Flat.directSum_iff._simp_1_2 | Mathlib.RingTheory.Flat.Basic | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
{σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂), ... | false |
CategoryTheory.ObjectProperty.isLocal.homEquiv_apply | Mathlib.CategoryTheory.Localization.Bousfield | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.ObjectProperty C} {X Y : C}
{f : X ⟶ Y} (hf : P.isLocal f) (Z : C) (hZ : P Z) (g : Y ⟶ Z),
(hf.homEquiv Z hZ) g = CategoryTheory.CategoryStruct.comp f g | true |
BitVec.setWidth_neg_of_le | Init.Data.BitVec.Bootstrap | ∀ {v w : ℕ} {x : BitVec v}, w ≤ v → BitVec.setWidth w (-x) = -BitVec.setWidth w x | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.