name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Aesop.Frontend.TacticConfig.simpConfig | Aesop.Frontend.Tactic | Aesop.Frontend.TacticConfig → Lean.Meta.Simp.Config | true |
LinearMap.linearIndependent_iff | Mathlib.LinearAlgebra.LinearIndependent.Basic | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {M' : Type u_5} {v : ι → M} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M'),
f.ker = ⊥ → (LinearIndependent R (⇑f ∘ v) ↔ LinearIndependent R v) | true |
CategoryTheory.Abelian.SpectralObject.map_fourδ₁Toδ₀_EMap_fourδ₄Toδ₃._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Homology | Lean.Syntax | false |
MeasureTheory.SimpleFunc.map_restrict_of_zero | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : Zero β] [inst_2 : Zero γ]
{g : β → γ},
g 0 = 0 →
∀ (f : MeasureTheory.SimpleFunc α β) (s : Set α),
MeasureTheory.SimpleFunc.map g (f.restrict s) = (MeasureTheory.SimpleFunc.map g f).restrict s | true |
instAddCommGroupPreLp._aux_17 | Mathlib.Analysis.Normed.Lp.lpSpace | {α : Type u_1} → (E : α → Type u_2) → [inst : (i : α) → NormedAddCommGroup (E i)] → ℤ → PreLp E → PreLp E | false |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.CtorHeaderResult.noConfusion | Lean.Elab.StructInst | {P : Sort u} →
{t t' : Lean.Elab.Term.StructInst.CtorHeaderResult✝} →
t = t' → Lean.Elab.Term.StructInst.CtorHeaderResult.noConfusionType✝ P t t' | false |
AddSubsemigroup.srange_snd | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] [Nonempty M], (AddHom.snd M N).srange = ⊤ | true |
PointedCone.dual_empty | Mathlib.Geometry.Convex.Cone.Dual | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] {M : Type u_2}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {N : Type u_3} [inst_5 : AddCommMonoid N] [inst_6 : Module R N]
{p : M →ₗ[R] N →ₗ[R] R}, PointedCone.dual p ∅ = ⊤ | true |
MulOpposite.instCoalgebra._proof_4 | Mathlib.RingTheory.Coalgebra.MulOpposite | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Coalgebra R A] (x : Aᵐᵒᵖ),
(LinearMap.rTensor Aᵐᵒᵖ CoalgebraStruct.counit ∘ₗ CoalgebraStruct.comul) x = ((TensorProduct.mk R R Aᵐᵒᵖ) 1) x | false |
CategoryTheory.Bicategory.Pith.pseudofunctorToPithCompInclusionStrongIsoHom._proof_4 | Mathlib.CategoryTheory.Bicategory.LocallyGroupoid | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {B' : Type u_5} [inst_1 : CategoryTheory.Bicategory B']
[inst_2 : CategoryTheory.Bicategory.IsLocallyGroupoid B'] (F : CategoryTheory.Pseudofunctor B' B) (a : B'),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.rightUnitor
(((Cat... | false |
ModuleCat.AlternatingMap | Mathlib.Algebra.Category.ModuleCat.ExteriorPower | {R : Type u} → [inst : CommRing R] → ModuleCat R → ModuleCat R → ℕ → Type (max (max v u v) 0) | true |
_private.Mathlib.RingTheory.MvPowerSeries.PiTopology.0.MvPowerSeries.WithPiTopology.summable_prod_of_tendsto_weightedOrder_atTop_nhds_top._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.PiTopology | ∀ {α : Type u_1} {l : Filter α} {f : α → ℕ∞}, Filter.Tendsto f l (nhds ⊤) = ∀ (n : ℕ), ∀ᶠ (a : α) in l, ↑n < f a | false |
Mathlib.Tactic.Reassoc.«_aux_Mathlib_Tactic_CategoryTheory_Reassoc___elabRules_Mathlib_Tactic_Reassoc_termReassoc_of%__1» | Mathlib.Tactic.CategoryTheory.Reassoc | Lean.Elab.Term.TermElab | false |
SimplexCategory.δ_comp_σ_of_le_assoc | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)},
i ≤ j.castSucc →
∀ {Z : SimplexCategory} (h : { len := n + 1 } ⟶ Z),
CategoryTheory.CategoryStruct.comp (SimplexCategory.δ i.castSucc)
(CategoryTheory.CategoryStruct.comp (SimplexCategory.σ j.succ) h) =
CategoryTheory.CategoryStruct.comp (Simp... | true |
StrictAnti.mul' | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Mul α] [inst_1 : Preorder α] [inst_2 : Preorder β] {f g : β → α}
[MulLeftStrictMono α] [MulRightStrictMono α], StrictAnti f → StrictAnti g → StrictAnti fun x => f x * g x | true |
ZeroAtInftyContinuousMap.ext_iff | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β]
{f g : ZeroAtInftyContinuousMap α β}, f = g ↔ ∀ (x : α), f x = g x | true |
_private.Mathlib.Data.List.Lemmas.0.List.injOn_insertIdx_index_of_notMem._simp_1_4 | Mathlib.Data.List.Lemmas | ∀ {a b : ℕ}, (a.succ ≤ b.succ) = (a ≤ b) | false |
List.destutter_eq_nil | Mathlib.Data.List.Destutter | ∀ {α : Type u_1} (R : α → α → Prop) [inst : DecidableRel R] {l : List α}, List.destutter R l = [] ↔ l = [] | true |
Filter.tendsto_nhds | Mathlib.Topology.Filter | ∀ {α : Type u_2} {β : Type u_3} {la : Filter α} {lb : Filter β} {f : α → Filter β},
Filter.Tendsto f la (nhds lb) ↔ ∀ s ∈ lb, ∀ᶠ (a : α) in la, s ∈ f a | true |
CategoryTheory.Triangulated.TStructure.triangleLTGE_distinguished | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.... | true |
_private.Lean.Elab.Tactic.BVDecide.LRAT.Trim.0.Lean.Elab.Tactic.BVDecide.LRAT.trim.computeToDelete.match_1 | Lean.Elab.Tactic.BVDecide.LRAT.Trim | (motive : Option (Array ℕ) → Sort u_1) →
(x : Option (Array ℕ)) → (Unit → motive none) → ((arr : Array ℕ) → motive (some arr)) → motive x | false |
CochainComplex.mapBifunctorHomologicalComplexShift₁Iso._proof_1 | Mathlib.Algebra.Homology.BifunctorShift | ∀ {C₁ : Type u_6} {C₂ : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
[inst_3 : CategoryTheory.Preadditive C₁] [inst_4 : CategoryTheory.Limits.HasZeroMorphisms C₂]
[inst_5 : CategoryTheory.Pr... | false |
AddCommGrpCat.hasForgetToAddGroup._proof_4 | Mathlib.Algebra.Category.Grp.Basic | { obj := fun X => AddGrpCat.of ↑X, map := fun {X Y} f => AddGrpCat.ofHom (AddCommGrpCat.Hom.hom f),
map_id := AddCommGrpCat.hasForgetToAddGroup._proof_1,
map_comp := @AddCommGrpCat.hasForgetToAddGroup._proof_2 }.comp
(CategoryTheory.forget AddGrpCat) =
CategoryTheory.forget AddCommGrpCat | false |
CategoryTheory.MonoidalSingleObj.endMonoidalStarFunctor | Mathlib.CategoryTheory.Bicategory.SingleObj | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.Functor (CategoryTheory.EndMonoidal (CategoryTheory.MonoidalSingleObj.star C)) C | true |
_private.Mathlib.Topology.EMetricSpace.Paracompact.0.Metric.instParacompactSpace._simp_4 | Mathlib.Topology.EMetricSpace.Paracompact | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {ε : ENNReal}, (y ∈ Metric.eball x ε) = (edist y x < ε) | false |
CategoryTheory.Functor.OplaxMonoidal.ofBifunctor.leftMapₗ | Mathlib.CategoryTheory.Monoidal.Multifunctor | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.MonoidalCategory D] →
(F : CategoryTheory.Functor C D) → F ⟶ F.comp (CategoryTheory.MonoidalCategory.tensorUnitLeft D) | true |
Lean.Meta.FastSubsingleton.rec | Mathlib.Lean.Meta.CongrTheorems | {α : Sort u} →
{motive : Lean.Meta.FastSubsingleton α → Sort u_1} →
([inst : Subsingleton α] → motive ⋯) → (t : Lean.Meta.FastSubsingleton α) → motive t | false |
CochainComplex.IsStrictlyGE | Mathlib.Algebra.Homology.Embedding.CochainComplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] → CochainComplex C ℤ → ℤ → Prop | true |
Array.extract_zipWith | Init.Data.Array.Zip | ∀ {α : Type u_1} {α_1 : Type u_2} {α_2 : Type u_3} {f : α → α_1 → α_2} {as : Array α} {bs : Array α_1} {i j : ℕ},
(Array.zipWith f as bs).extract i j = Array.zipWith f (as.extract i j) (bs.extract i j) | true |
Lean.Meta.mkFixOfMonFun | Lean.Meta.Order | Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | true |
CategoryTheory.Preadditive.instSemiringEnd._proof_4 | Mathlib.CategoryTheory.Preadditive.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X : C} (n : ℕ),
(n + 1).unaryCast = n.unaryCast + 1 | false |
Aesop.GoalUnsafe.brecOn_9.eq | Aesop.Tree.Data | ∀ {motive_1 : Aesop.GoalUnsafe → Sort u} {motive_2 : Aesop.MVarClusterUnsafe → Sort u}
{motive_3 : Aesop.RappUnsafe → Sort u} {motive_4 : Aesop.GoalData Aesop.RappUnsafe Aesop.MVarClusterUnsafe → Sort u}
{motive_5 : Aesop.MVarClusterData Aesop.GoalUnsafe Aesop.RappUnsafe → Sort u}
{motive_6 : Aesop.RappData Aesop... | true |
AddMonoid.Coprod.clift_comp_mk | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
[inst_2 : AddZeroClass P] (f : FreeAddMonoid (M ⊕ N) →+ P) (hM₁ : f (FreeAddMonoid.of (Sum.inl 0)) = 0)
(hN₁ : f (FreeAddMonoid.of (Sum.inr 0)) = 0)
(hM :
∀ (x y : M),
f (FreeAddMonoid.of (Sum.inl (x + y))) ... | true |
Continuous.inf' | Mathlib.Topology.Order.Lattice | ∀ {L : Type u_1} {X : Type u_2} [inst : TopologicalSpace L] [inst_1 : TopologicalSpace X] [inst_2 : Min L]
[ContinuousInf L] {f g : X → L}, Continuous f → Continuous g → Continuous (f ⊓ g) | true |
Mathlib.Meta.NormNum.NormNumExt | Mathlib.Tactic.NormNum.Core | Type | true |
_private.Init.Data.String.Lemmas.Pattern.Find.Pred.0.String.Pos.find?_prop_eq_some_iff_splits._simp_1_1 | Init.Data.String.Lemmas.Pattern.Find.Pred | ∀ {p : Prop} {x : Decidable p}, (decide p = false) = ¬p | false |
Left.one_le_pow_of_le._f | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M] [MulLeftMono M] {a : M},
1 ≤ a → ∀ (x : ℕ) (f : Nat.below x), 1 ≤ a ^ x | false |
_private.Mathlib.RingTheory.Smooth.AdicCompletion.0.Algebra.FormallySmooth.liftAdicCompletionAux.match_1.eq_3 | Mathlib.RingTheory.Smooth.AdicCompletion | ∀ (motive : ℕ → Sort u_1) (m : ℕ) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (m : ℕ) → motive m.succ.succ),
(match m.succ.succ with
| 0 => h_1 ()
| 1 => h_2 ()
| m.succ.succ => h_3 m) =
h_3 m | true |
Mathlib.Tactic.LibraryRewrite.RewriteInterface.symm | Mathlib.Tactic.Widget.LibraryRewrite | Mathlib.Tactic.LibraryRewrite.RewriteInterface → Bool | true |
Lean.Grind.Ring.OfSemiring.instAssociativeHMul | Init.Grind.Ring.Envelope | ∀ (α : Type u) [inst : Lean.Grind.Semiring α], Std.Associative fun x1 x2 => x1 * x2 | true |
Std.Time.Hour.Offset.ofInt | Std.Time.Time.Unit.Hour | ℤ → Std.Time.Hour.Offset | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.BlastDivSubtractShiftOutput | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv | {α : Type} → [inst : Hashable α] → [inst_1 : DecidableEq α] → Std.Sat.AIG α → ℕ → Type | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_of_ge._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (i : ℕ), w ≤ i → i < w → False | false |
Bundle.Trivialization.continuousLinearEquivAt._proof_4 | Mathlib.Topology.VectorBundle.Basic | ∀ (R : Type u_3) {B : Type u_4} {F : Type u_1} {E : B → Type u_2} [inst : NontriviallyNormedField R]
[inst_1 : (x : B) → AddCommMonoid (E x)] [inst_2 : (x : B) → Module R (E x)] [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace R F] [inst_5 : TopologicalSpace B] [inst_6 : TopologicalSpace (Bundle.TotalSpace F E... | false |
Polynomial.isEquivalent_atBot_lead | Mathlib.Analysis.Polynomial.Basic | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] (P : Polynomial 𝕜)
[OrderTopology 𝕜],
Asymptotics.IsEquivalent Filter.atBot (fun x => Polynomial.eval x P) fun x => P.leadingCoeff * x ^ P.natDegree | true |
_private.Aesop.Index.Basic.0.Aesop.IndexingMode.format.match_1 | Aesop.Index.Basic | (motive : Aesop.IndexingMode → Sort u_1) →
(x : Aesop.IndexingMode) →
(Unit → motive Aesop.IndexingMode.unindexed) →
((keys : Array Lean.Meta.DiscrTree.Key) → motive (Aesop.IndexingMode.target keys)) →
((keys : Array Lean.Meta.DiscrTree.Key) → motive (Aesop.IndexingMode.hyps keys)) →
((imo... | false |
UInt64.not_and_self | Init.Data.UInt.Bitwise | ∀ {a : UInt64}, ~~~a &&& a = 0 | true |
instRingCliffordAlgebra._proof_31 | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M),
autoParam
(∀ (n : ℕ) (x : CliffordAlgebra Q),
instRingCliffordAlgebra._aux_28 Q (n + 1) x = instRingCliffordAlgebra._aux_28 Q n x * x)
Monoid.npow_succ._autoParam | false |
BitVec.getLsbD_rotateRight | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {r i : ℕ},
(x.rotateRight r).getLsbD i =
bif decide (i < w - r % w) then x.getLsbD (r % w + i) else decide (i < w) && x.getLsbD (i - (w - r % w)) | true |
Array.getElem_extract_loop_ge_aux | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs ys : Array α} {size start : ℕ},
i ≥ ys.size → i < (Array.extract.loop xs size start ys).size → start + i - ys.size < xs.size | true |
Int64.le_of_eq | Init.Data.SInt.Lemmas | ∀ {a b : Int64}, a = b → a ≤ b | true |
segment_subset_convexJoin | Mathlib.Analysis.Convex.Join | ∀ {𝕜 : Type u_2} {E : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] {s t : Set E} {x y : E}, x ∈ s → y ∈ t → segment 𝕜 x y ⊆ convexJoin 𝕜 s t | true |
Nat.eq_zero_of_le_zero | Init.Data.Nat.Basic | ∀ {n : ℕ}, n ≤ 0 → n = 0 | true |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.clearUnit | Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation | {n : ℕ} →
Array Std.Tactic.BVDecide.LRAT.Internal.Assignment →
Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) → Array Std.Tactic.BVDecide.LRAT.Internal.Assignment | true |
_private.Mathlib.FieldTheory.PolynomialGaloisGroup.0.Polynomial.Gal.mapRoots_bijective._simp_1_3 | Mathlib.FieldTheory.PolynomialGaloisGroup | ∀ {α : Type u_1} {β : Type v} {f : α → β} {b : β} {s : Multiset α}, (b ∈ Multiset.map f s) = ∃ a ∈ s, f a = b | false |
_private.Mathlib.LinearAlgebra.QuadraticForm.Radical.0.QuadraticForm.radical_weightedSumSquares._proof_1_9 | Mathlib.LinearAlgebra.QuadraticForm.Radical | (1 + 1).AtLeastTwo | false |
Std.ExtHashSet.mem_ofList | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α] {l : List α} {k : α},
k ∈ Std.ExtHashSet.ofList l ↔ l.contains k = true | true |
Ordinal.IsInitial.eq_1 | Mathlib.SetTheory.Cardinal.Aleph | ∀ (o : Ordinal.{u_1}), o.IsInitial = (o.card.ord = o) | true |
HomotopicalAlgebra.LeftHomotopyRel.rightHomotopy._proof_2 | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {X Y : C}
{f g : X ⟶ Y} (h : HomotopicalAlgebra.LeftHomotopyRel f g) (Q : HomotopicalAlgebra.PathObject Y)
(h_1 : ⋯.choose.LeftHomotopy f g),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStru... | false |
TensorProduct._aux_Mathlib_LinearAlgebra_TensorProduct_Defs___unexpand_TensorProduct_tmul_1 | Mathlib.LinearAlgebra.TensorProduct.Defs | Lean.PrettyPrinter.Unexpander | false |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.fieldFromMsg | Lean.Elab.Structure | Lean.Elab.Command.Structure.StructFieldInfo → Lean.MessageData | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.ParamMap.Key.decl.noConfusion | Lean.Compiler.LCNF.InferBorrow | {P : Sort u} →
{name name' : Lean.Name} →
Lean.Compiler.LCNF.ParamMap.Key.decl✝ name = Lean.Compiler.LCNF.ParamMap.Key.decl✝ name' → (name = name' → P) → P | false |
Std.TreeMap.Equiv.maxEntry!_eq | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited (α × β)], t₁.Equiv t₂ → t₁.maxEntry! = t₂.maxEntry! | true |
DilationEquiv.mulRight_symm_apply | Mathlib.Analysis.Normed.Field.Lemmas | ∀ {α : Type u_1} [inst : NormedDivisionRing α] (a : α) (ha : a ≠ 0) (x : α),
(DilationEquiv.mulRight a ha).symm x = x * a⁻¹ | true |
SimpleGraph.Walk.nil_nil | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u} {G : SimpleGraph V} {u : V}, SimpleGraph.Walk.nil.Nil | true |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.extract.match_1.splitter | Batteries.Data.String.Lemmas | (motive : Substring.Raw → String.Pos.Raw → String.Pos.Raw → Sort u_1) →
(x : Substring.Raw) →
(x_1 x_2 : String.Pos.Raw) →
((s : String) → (b e b' e' : String.Pos.Raw) → motive { str := s, startPos := b, stopPos := e } b' e') →
motive x x_1 x_2 | true |
IsLocalization.instQuotientIdealAlgebraMapSubmonoidMapRingHomAlgebraMap | Mathlib.RingTheory.Localization.Ideal | ∀ {R : Type u_1} [inst : CommRing R] (M : Submonoid R) (S : Type u_2) [inst_1 : CommRing S] [inst_2 : Algebra R S]
[IsLocalization M S] (I : Ideal R),
IsLocalization (Algebra.algebraMapSubmonoid (R ⧸ I) M) (S ⧸ Ideal.map (algebraMap R S) I) | true |
SpectralMap.casesOn | Mathlib.Topology.Spectral.Hom | {α : Type u_6} →
{β : Type u_7} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
{motive : SpectralMap α β → Sort u} →
(t : SpectralMap α β) →
((toFun : α → β) → (spectral' : IsSpectralMap toFun) → motive { toFun := toFun, spectral' := spectral' }) →
... | false |
Finset.toDual_min' | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α] {s : Finset α} (hs : s.Nonempty),
OrderDual.toDual (s.min' hs) = (Finset.image (⇑OrderDual.toDual) s).max' ⋯ | true |
_private.Mathlib.Data.Multiset.ZeroCons.0.Multiset.singleton_subset._simp_1_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {s t : Multiset α}, (s ⊆ t) = ∀ ⦃x : α⦄, x ∈ s → x ∈ t | false |
Lean.Lsp.SignatureInformation.parameters?._default | Lean.Data.Lsp.LanguageFeatures | Option (Array Lean.Lsp.ParameterInformation) | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.MDifferentiable.0.E2_mdifferentiable._simp_1_3 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.MDifferentiable | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | false |
CategoryTheory.Limits.kernelSubobject_arrow'_assoc | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f] {Z : C} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernelSubobjectIso f).inv
(CategoryTheory.CategoryStruc... | true |
SimpleGraph.TripartiteFromTriangles.ExplicitDisjoint | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | {α : Type u_1} → {β : Type u_2} → {γ : Type u_3} → Finset (α × β × γ) → Prop | true |
Prod.instSubtractionMonoid.eq_1 | Mathlib.Algebra.Group.Prod | ∀ {G : Type u_1} {H : Type u_2} [inst : SubtractionMonoid G] [inst_1 : SubtractionMonoid H],
Prod.instSubtractionMonoid =
{ toSubNegMonoid := Prod.subNegMonoid, neg_neg := ⋯, neg_add_rev := ⋯, neg_eq_of_add := ⋯ } | true |
Valuation.IsRankOneDiscrete.generator_mem_range | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] (K : Type u_3) [inst_1 : Field K] (w : Valuation K Γ)
[inst_2 : w.IsRankOneDiscrete], ↑(Valuation.IsRankOneDiscrete.generator w) ∈ Set.range ⇑w | true |
CategoryTheory.Limits.ConeMorphism.recOn | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{A B : CategoryTheory.Limits.Cone F} →
{motive : CategoryTheory.Limits.ConeMorphism A B → Sort u} →
(t ... | false |
Int.gcdA | Mathlib.Data.Int.GCD | ℤ → ℤ → ℤ | true |
Std.TreeSet.Raw.isEmpty | Std.Data.TreeSet.Raw.Basic | {α : Type u} → {cmp : α → α → Ordering} → Std.TreeSet.Raw α cmp → Bool | true |
SubStarSemigroup.noConfusion | Mathlib.Algebra.Star.NonUnitalSubsemiring | {P : Sort u} →
{M : Type v} →
{inst : Mul M} →
{inst_1 : Star M} →
{t : SubStarSemigroup M} →
{M' : Type v} →
{inst' : Mul M'} →
{inst'_1 : Star M'} →
{t' : SubStarSemigroup M'} →
M = M' → inst ≍ inst' → inst_1 ≍ inst'_1 → t ≍ t' ... | false |
ProbabilityTheory.HasGaussianLaw.aemeasurable | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} [inst : TopologicalSpace E]
[inst_1 : AddCommMonoid E] [inst_2 : Module ℝ E] [mE : MeasurableSpace E] {X : Ω → E},
ProbabilityTheory.HasGaussianLaw X P → AEMeasurable X P | true |
MulAction.toPerm_injective | Mathlib.Algebra.Group.Action.Basic | ∀ {α : Type u_5} {β : Type u_6} [inst : Group α] [inst_1 : MulAction α β] [FaithfulSMul α β],
Function.Injective MulAction.toPerm | true |
TypeVec.splitFun.eq_1 | Mathlib.Data.PFunctor.Multivariate.M | ∀ {n : ℕ} {α : TypeVec.{u_1} (n + 1)} {α' : TypeVec.{u_2} (n + 1)} (f : α.drop.Arrow α'.drop) (g : α.last → α'.last)
(i : Fin2 n), TypeVec.splitFun f g i.fs = f i | true |
Substring.Raw.Internal.isEmptyImpl | Init.Data.String.Substring | Substring.Raw → Bool | true |
Finsupp.lift._proof_1 | Mathlib.LinearAlgebra.Finsupp.LSum | ∀ (M : Type u_2) (R : Type u_1) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
SMulCommClass R ℕ M | false |
Vector.exists_of_mem_mapIdx | Init.Data.Vector.MapIdx | ∀ {β : Type u_1} {α : Type u_2} {n : ℕ} {f : ℕ → α → β} {b : β} {xs : Vector α n},
b ∈ Vector.mapIdx f xs → ∃ i, ∃ (h : i < n), f i xs[i] = b | true |
Cycle.lists._proof_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} (l₁ l₂ : List α),
(List.IsRotated.setoid α) l₁ l₂ → (fun l => ↑l.cyclicPermutations) l₁ = (fun l => ↑l.cyclicPermutations) l₂ | false |
_private.Mathlib.NumberTheory.LSeries.AbstractFuncEq.0.WeakFEPair.hf_zero._simp_1_3 | Mathlib.NumberTheory.LSeries.AbstractFuncEq | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
SimpleGraph.binomialRandom_apply | Mathlib.Probability.Combinatorics.BinomialRandomGraph.Defs | ∀ {V : Type u_1} (p : ↑unitInterval) [Countable V] (S : Set (SimpleGraph V)),
(SimpleGraph.binomialRandom V p) S =
(MeasureTheory.Measure.infinitePi fun e =>
(unitInterval.toNNReal p • MeasureTheory.Measure.dirac ¬e.IsDiag) +
unitInterval.toNNReal (unitInterval.symm p) • MeasureTheory.Measure.di... | true |
TangentSpace | Mathlib.Geometry.Manifold.IsManifold.Basic | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_2} →
[inst_3 : TopologicalSpace H] →
ModelWithCorners 𝕜 E H → {M : Type u_3} → [inst : TopologicalSpace M] → [Charte... | true |
CategoryTheory.Limits.PreservesCofilteredLimitsOfSize.mk | Mathlib.CategoryTheory.Limits.Preserves.Filtered | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D},
(∀ (J : Type w) [inst_2 : CategoryTheory.Category.{w', w} J] [CategoryTheory.IsCofiltered J],
CategoryTheory.Limits.PreservesLimitsOfShape J F) →
Catego... | true |
_private.Init.Data.Iterators.Lemmas.Consumers.Loop.0.Std.IterM.DefaultConsumers.forIn'_eq_match_step.match_3.eq_2 | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type u_1} {m : Type u_1 → Type u_2} [inst : Std.Iterator α m β] {it : Std.IterM m β}
(motive : it.Step → Sort u_3) (it' : Std.IterM m β) (h : it.IsPlausibleStep (Std.IterStep.skip it'))
(h_1 :
(it' : Std.IterM m β) →
(out : β) → (h : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.... | true |
Lean.Lsp.CodeActionLiteralSupport._sizeOf_1 | Lean.Data.Lsp.CodeActions | Lean.Lsp.CodeActionLiteralSupport → ℕ | false |
_private.Mathlib.ModelTheory.Definability.0.Set.Definable.image_comp_sumInl_fin._simp_1_3 | Mathlib.ModelTheory.Definability | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {β : Type v'} {m n : ℕ}
{φ : L.BoundedFormula α n} {g : α → β ⊕ Fin m} {v : β → M} {xs : Fin (m + n) → M},
(FirstOrder.Language.BoundedFormula.relabel g φ).Realize v xs =
φ.Realize (Sum.elim v (xs ∘ Fin.castAdd n) ∘ g) (xs ∘ Fin.natAd... | false |
_private.Mathlib.Analysis.MeanInequalities.0.ENNReal.inner_le_Lp_mul_Lq._simp_1_2 | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u_1} {N : Type u_5} [inst : AddCommMonoid N] [inst_1 : PartialOrder N] {f : ι → N} {s : Finset ι}
[AddLeftMono N], (∀ i ∈ s, 0 ≤ f i) → (∑ i ∈ s, f i = 0) = ∀ i ∈ s, f i = 0 | false |
TensorPower.gmonoid._proof_4 | Mathlib.LinearAlgebra.TensorPower.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(x : GradedMonoid fun i => TensorPower R i M), x * 1 = x | false |
_private.Mathlib.Data.Finsupp.Single.0.Finsupp.card_support_le_one._simp_1_1 | Mathlib.Data.Finsupp.Single | ∀ {α : Type u_1} {s : Finset α} [Nonempty α], (s.card ≤ 1) = ∃ x, s ⊆ {x} | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_map._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
OrderHom.eq_id_of_injective | Mathlib.Data.Finset.Sort | ∀ {α : Type u_1} [inst : LinearOrder α] [Finite α] (f : α →o α), Function.Injective ⇑f → f = OrderHom.id | true |
List.mem_rotate | Mathlib.Data.List.Rotate | ∀ {α : Type u} {l : List α} {a : α} {n : ℕ}, a ∈ l.rotate n ↔ a ∈ l | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.