name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.Time.Modifier.x.injEq | Std.Time.Format.Basic | ∀ (presentation presentation_1 : Std.Time.OffsetX),
(Std.Time.Modifier.x presentation = Std.Time.Modifier.x presentation_1) = (presentation = presentation_1) | true |
CategoryTheory.Limits.FormalCoproduct.isoOfComponents._proof_7 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {X Y : CategoryTheory.Limits.FormalCoproduct C}
(e : X.I ≃ Y.I) (h : (i : X.I) → X.obj i ≅ Y.obj (e i)),
CategoryTheory.CategoryStruct.comp
{ f := ⇑e.symm, φ := fun i => CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (h (e.symm i)).... | false |
SeminormedCommRing.mk | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} → [toSeminormedRing : SeminormedRing α] → (∀ (a b : α), a * b = b * a) → SeminormedCommRing α | true |
CategoryTheory.InducedCategory.hasForget₂._proof_1 | Mathlib.CategoryTheory.ConcreteCategory.Forget | ∀ {C : Type u_1} {D : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} D] {FD : outParam (D → D → Type u_5)}
{CD : outParam (D → Type u_3)} [inst_1 : outParam ((X Y : D) → FunLike (FD X Y) (CD X) (CD Y))]
[inst_2 : CategoryTheory.ConcreteCategory D FD] (f : C → D),
(CategoryTheory.inducedFunctor f).comp (Cate... | false |
CategoryTheory.LaxFunctor.mapComp'.congr_simp | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.LaxFunctor B C) {b₀ b₁ b₂ : B} (f : b₀ ⟶ b₁) (g : b₁ ⟶ b₂) (fg : b₀ ⟶ b₂)
(h : CategoryTheory.CategoryStruct.comp f g = fg), F.mapComp' f g fg h = F.mapComp' f g fg h | true |
CategoryTheory.Limits.IsZero.iso.congr_simp | Mathlib.CategoryTheory.Triangulated.Opposite.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (hX : CategoryTheory.Limits.IsZero X)
(hY : CategoryTheory.Limits.IsZero Y), hX.iso hY = hX.iso hY | true |
CategoryTheory.Functor.CommShift₂.commShiftObj | Mathlib.CategoryTheory.Shift.CommShiftTwo | {C₁ : Type u_1} →
{C₂ : Type u_3} →
{D : Type u_5} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_3, u_3} C₂} →
{inst_2 : CategoryTheory.Category.{v_5, u_5} D} →
{M : Type u_6} →
{inst_3 : AddCommMonoid M} →
... | true |
PNat.instMetricSpace._proof_8 | Mathlib.Topology.Instances.PNat | autoParam (∀ (x y : ℕ+), PNat.instMetricSpace._aux_6 x y = ENNReal.ofReal (dist x y))
PseudoMetricSpace.edist_dist._autoParam | false |
Multiset.le_iff_exists_add | Mathlib.Data.Multiset.AddSub | ∀ {α : Type u_1} {s t : Multiset α}, s ≤ t ↔ ∃ u, t = s + u | true |
Lean.InductiveVal.numNested | Lean.Declaration | Lean.InductiveVal → ℕ | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint_preserves_invariant_helper._proof_1_20 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ}
(acc :
Array Std.Tactic.BVDecide.LRAT.Internal.Assignment ×
Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) × Bool × Bool),
acc.1.size = n →
∀ (l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)) (i : Fin n),
↑i < acc.1.size → ↑i < (acc.1.modify (↑l.1) (St... | false |
_private.Mathlib.CategoryTheory.Idempotents.Karoubi.0.CategoryTheory.Idempotents.instEssSurjKaroubiToKaroubiOfIsIdempotentComplete._simp_1 | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h | false |
AddLECancellable.tsub_mul | Mathlib.Algebra.Order.Ring.Canonical | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] [inst_1 : PartialOrder R] [CanonicallyOrderedAdd R] [inst_3 : Sub R]
[OrderedSub R] [Std.Total fun x1 x2 => x1 ≤ x2] [MulRightMono R] {a b c : R},
AddLECancellable (b * c) → (a - b) * c = a * c - b * c | true |
Std.Tactic.BVDecide.Normalize.BitVec.ult_max' | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {w : ℕ} (a : BitVec w), a.ult (-1#w) = !a == -1#w | true |
BddDistLat.recOn | Mathlib.Order.Category.BddDistLat | {motive : BddDistLat → Sort u} →
(t : BddDistLat) →
((toDistLat : DistLat) →
[isBoundedOrder : BoundedOrder ↑toDistLat] →
motive { toDistLat := toDistLat, isBoundedOrder := isBoundedOrder }) →
motive t | false |
ContinuousLinearEquiv.arrowCongrEquiv._proof_4 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_7} {R₂ : Type u_1} {R₃ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃]
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} [inst_3 : RingHomInvPair σ₁₂ σ₂₁] [inst_4 : RingHomInvPair σ₂₁ σ₁₂]
{σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_5 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] {M₁ : Type u_8}
... | false |
Submodule.coe_finsetInf | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_4}
(s : Finset ι) (p : ι → Submodule R M), ↑(s.inf p) = ⋂ i ∈ s, ↑(p i) | true |
Matroid.Indep.mem_closure_iff' | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {I : Set α} {x : α},
M.Indep I → (x ∈ M.closure I ↔ x ∈ M.E ∧ (M.Indep (insert x I) → x ∈ I)) | true |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.moebius_inversion_top._simp_1_7 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | false |
Finset.instLattice._proof_3 | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (x x_1 x_2 : Finset α), x ≤ x_2 → x_1 ≤ x_2 → ∀ x_3 ∈ x ∪ x_1, x_3 ∈ x_2 | false |
intervalIntegrable_log_norm_meromorphicOn | Mathlib.Analysis.SpecialFunctions.Integrability.LogMeromorphic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {a b : ℝ},
MeromorphicOn f (Set.uIcc a b) → IntervalIntegrable (fun x => Real.log ‖f x‖) MeasureTheory.volume a b | true |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.getParentProjArg._sparseCasesOn_8.else_eq | Lean.Elab.DeclNameGen | ∀ {motive : Lean.Name → Sort u} (t : Lean.Name) (str : (pre : Lean.Name) → (str : String) → motive (pre.str str))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Lean.Elab.Command.NameGen.getParentProjArg._sparseCasesOn_8✝ t str «else» = «else» h | false |
VectorBundleCore.coordChange | Mathlib.Topology.VectorBundle.Basic | {R : Type u_1} →
{B : Type u_2} →
{F : Type u_3} →
[inst : NontriviallyNormedField R] →
[inst_1 : NormedAddCommGroup F] →
[inst_2 : NormedSpace R F] →
[inst_3 : TopologicalSpace B] → {ι : Type u_5} → VectorBundleCore R B F ι → ι → ι → B → F →L[R] F | true |
Lean.IR.CtorInfo.mk.inj | Lean.Compiler.IR.Basic | ∀ {name : Lean.Name} {cidx size usize ssize : ℕ} {name_1 : Lean.Name} {cidx_1 size_1 usize_1 ssize_1 : ℕ},
{ name := name, cidx := cidx, size := size, usize := usize, ssize := ssize } =
{ name := name_1, cidx := cidx_1, size := size_1, usize := usize_1, ssize := ssize_1 } →
name = name_1 ∧ cidx = cidx_1 ∧ s... | true |
Matrix.uniqueRingEquiv._proof_2 | Mathlib.LinearAlgebra.Matrix.Unique | ∀ {m : Type u_1} {A : Type u_2} [inst : Unique m] [inst_1 : NonUnitalNonAssocSemiring A] (x y : Matrix m m A),
Matrix.uniqueAddEquiv.toFun (x + y) = Matrix.uniqueAddEquiv.toFun x + Matrix.uniqueAddEquiv.toFun y | false |
Batteries.RBNode.All.map | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} {q : β → Prop} {f : α → β},
(∀ {x : α}, p x → q (f x)) →
∀ {t : Batteries.RBNode α}, Batteries.RBNode.All p t → Batteries.RBNode.All q (Batteries.RBNode.map f t) | true |
CochainComplex.homologyδOfTriangle._auto_1 | Mathlib.Algebra.Homology.DerivedCategory.HomologySequence | Lean.Syntax | false |
_private.Mathlib.Geometry.Manifold.ChartedSpace.0.ChartedSpace.t1Space._simp_1_1 | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | false |
Lean.ScopedEnvExtension.ScopedEntries.mk.injEq | Lean.ScopedEnvExtension | ∀ {β : Type} (map map_1 : Lean.SMap Lean.Name (Lean.PArray β)), ({ map := map } = { map := map_1 }) = (map = map_1) | true |
CategoryTheory.Functor.sheafPullbackConstruction.preservesFiniteLimits | Mathlib.CategoryTheory.Sites.Pullback | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} D]
(G : CategoryTheory.Functor C D) (A : Type u₁) [inst_2 : CategoryTheory.Category.{v₁, u₁} A]
(J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [inst_3 : G.IsC... | true |
OrderIso.arrowCongr | Mathlib.Order.Hom.Basic | {α : Type u_6} →
{β : Type u_7} →
{γ : Type u_8} →
{δ : Type u_9} →
[inst : Preorder α] →
[inst_1 : Preorder β] → [inst_2 : Preorder γ] → [inst_3 : Preorder δ] → α ≃o γ → β ≃o δ → (α →o β) ≃o (γ →o δ) | true |
_private.Lean.Meta.Sorry.0.Lean.Meta.SorryLabelView.encode.match_1 | Lean.Meta.Sorry | (motive : Option Lean.DeclarationLocation → Sort u_1) →
(x : Option Lean.DeclarationLocation) →
((module : Lean.Name) →
(pos : Lean.Position) →
(charUtf16 : ℕ) →
(endPos : Lean.Position) →
(endCharUtf16 : ℕ) →
motive
(some
... | false |
Set.finite_Ico._simp_1 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [LocallyFiniteOrder α] (a b : α), (Set.Ico a b).Finite = True | false |
Lean.Lsp.instHashableInsertReplaceEdit.hash | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.InsertReplaceEdit → UInt64 | true |
Aesop.instInhabitedRuleTacDescr.default | Aesop.RuleTac.Descr | Aesop.RuleTacDescr | true |
MeasureTheory.setLIntegral_withDensity_eq_lintegral_mul₀ | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
AEMeasurable f μ →
∀ {g : α → ENNReal},
AEMeasurable g μ →
∀ {s : Set α}, MeasurableSet s → ∫⁻ (a : α) in s, g a ∂μ.withDensity f = ∫⁻ (a : α) in s, (f * g) a ∂μ | true |
cfcₙHomSuperset | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | {R : Type u_1} →
{A : Type u_2} →
{p : A → Prop} →
[inst : CommSemiring R] →
[inst_1 : Nontrivial R] →
[inst_2 : StarRing R] →
[inst_3 : MetricSpace R] →
[inst_4 : IsTopologicalSemiring R] →
[inst_5 : ContinuousStar R] →
[inst_6 :... | true |
String.Slice.copy_slice_eq_iff_splits | Init.Data.String.Lemmas.Splits | ∀ {t : String} {s : String.Slice} {pos₁ pos₂ : s.Pos},
(∃ (h : pos₁ ≤ pos₂), (s.slice pos₁ pos₂ h).copy = t) ↔ ∃ t₁ t₂, pos₁.Splits t₁ (t ++ t₂) ∧ pos₂.Splits (t₁ ++ t) t₂ | true |
instInhabitedAsBoolRing | Mathlib.Algebra.Ring.BooleanRing | {α : Type u_1} → [Inhabited α] → Inhabited (AsBoolRing α) | true |
Fin.partialProd.eq_1 | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : Monoid M] {n : ℕ} (f : Fin n → M) (i : Fin (n + 1)),
Fin.partialProd f i = (List.take (↑i) (List.ofFn f)).prod | true |
GenContFract.contsAux_eq_contsAux_squashGCF_of_le | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | ∀ {K : Type u_1} {n : ℕ} {g : GenContFract K} [inst : DivisionRing K] {m : ℕ},
m ≤ n → g.contsAux m = (g.squashGCF n).contsAux m | true |
LinearIsometryEquiv.rTensor | Mathlib.Analysis.InnerProductSpace.TensorProduct | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
(G : Type u_4) →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : InnerProductSpace 𝕜 F] →
... | true |
Lean.Elab.Term.TacticMVarKind.autoParam.elim | Lean.Elab.Term.TermElabM | {motive : Lean.Elab.Term.TacticMVarKind → Sort u} →
(t : Lean.Elab.Term.TacticMVarKind) →
t.ctorIdx = 1 → ((argName : Lean.Name) → motive (Lean.Elab.Term.TacticMVarKind.autoParam argName)) → motive t | false |
Fin.rev_anti | Mathlib.Order.Fin.Basic | ∀ {n : ℕ}, Antitone Fin.rev | true |
_private.Mathlib.Data.EReal.Operations.0.EReal.le_sub_iff_add_le._simp_1_3 | Mathlib.Data.EReal.Operations | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a ≤ ⊥) = (a = ⊥) | false |
Lean.Meta.Grind.Arith.traceModel | Lean.Meta.Tactic.Grind.Arith.ModelUtil | Lean.Name → Array (Lean.Expr × ℚ) → Lean.MetaM Unit | true |
Finset.max_abv_sum_one_le | Mathlib.NumberTheory.Height.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : CommSemiring S] [inst_2 : LinearOrder S] [IsOrderedRing S]
[CharZero S] (v : AbsoluteValue R S) {ι : Type u_3} {s : Finset ι},
s.Nonempty → ∀ (x : ι → R), max (v (∑ i ∈ s, x i)) 1 ≤ ↑s.card * ∏ i ∈ s, max (v (x i)) 1 | true |
_private.Mathlib.CategoryTheory.Monoidal.Multifunctor.0.CategoryTheory.MonoidalCategory.curriedTensorPreFunctor._simp_1 | Mathlib.CategoryTheory.Monoidal.Multifunctor | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
{Y₁ Y₂ : C} (f : Y₁ ⟶ Y₂),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f =
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X) f | false |
MonotoneOn.convex_le | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder E] [IsOrderedAddMonoid E] [inst_5 : PartialOrder β] [inst_6 : Module 𝕜 E] [PosSMulMono 𝕜 E]
{s : Set E} {f : E → β}, MonotoneOn f s → Convex 𝕜 s → ∀ (r : β), Convex 𝕜 ... | true |
Submodule.equivOpposite._proof_5 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Semiring A] [inst_2 : Algebra R A]
(x : (Submodule R A)ᵐᵒᵖ),
MulOpposite.op
(Submodule.comap (↑(MulOpposite.opLinearEquiv R))
(Submodule.comap (↑(MulOpposite.opLinearEquiv R).symm) (MulOpposite.unop x))) =
x | false |
CategoryTheory.CommSq.rightAdjointLiftStructEquiv | Mathlib.CategoryTheory.LiftingProperties.Adjunction | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{G : CategoryTheory.Functor C D} →
{F : CategoryTheory.Functor D C} →
{A B : C} →
{X Y : D} →
{i : A ⟶ B} →
... | true |
CategoryTheory.Limits.limitObjIsoLimitCompEvaluation_inv_π_app | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasLimitsOfShape J C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) (j : J) (k : K),
Catego... | true |
MeasureTheory.setLIntegral_measure_zero | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (s : Set α) (f : α → ENNReal),
μ s = 0 → ∫⁻ (x : α) in s, f x ∂μ = 0 | true |
Std.ExtTreeMap.getKeyGE? | Std.Data.ExtTreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeMap α β cmp → α → Option α | true |
Lean.Compiler.LCNF.Simp.Config.casesOn | Lean.Compiler.LCNF.Simp.Config | {motive : Lean.Compiler.LCNF.Simp.Config → Sort u} →
(t : Lean.Compiler.LCNF.Simp.Config) →
((etaPoly inlinePartial implementedBy inlineDefs : Bool) →
motive
{ etaPoly := etaPoly, inlinePartial := inlinePartial, implementedBy := implementedBy,
inlineDefs := inlineDefs }) →
moti... | false |
ContinuousMap.HomotopyEquiv.prodCongr | Mathlib.Topology.Homotopy.Equiv | {X : Type u} →
{Y : Type v} →
{Z : Type w} →
{Z' : Type x} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
[inst_2 : TopologicalSpace Z] →
[inst_3 : TopologicalSpace Z'] →
ContinuousMap.HomotopyEquiv X Y →
Continuo... | true |
TopologicalSpace.UpgradedIsCompletelyMetrizableSpace.edist._inherited_default | Mathlib.Topology.Metrizable.CompletelyMetrizable | {X : Type u_3} →
(dist : X → X → ℝ) →
(∀ (x : X), dist x x = 0) →
(∀ (x y : X), dist x y = dist y x) → (∀ (x y z : X), dist x z ≤ dist x y + dist y z) → X → X → ENNReal | false |
_private.Mathlib.GroupTheory.Perm.Fin.0.Fin.cycleIcc_of_le_of_le._proof_1_17 | Mathlib.GroupTheory.Perm.Fin | ∀ {n : ℕ} {i k : Fin n}, i ≤ k → ↑k - ↑i + 1 + (n - (n - ↑i)) = ↑k + 1 | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.0.Lean.Meta.Grind.Arith.Cutsat.initFn._@.Lean.Meta.Tactic.Grind.Arith.Cutsat.798741302._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind.Arith.Cutsat | IO Unit | false |
Set.sups_assoc | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeSup α] (s t u : Set α), s ⊻ t ⊻ u = s ⊻ (t ⊻ u) | true |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.MessageOverview.request.elim | Lean.Server.ProtocolOverview | {motive : Lean.Server.Overview.MessageOverview✝ → Sort u} →
(t : Lean.Server.Overview.MessageOverview✝¹) →
Lean.Server.Overview.MessageOverview.ctorIdx✝ t = 0 →
((o : Lean.Server.Overview.RequestOverview✝) → motive (Lean.Server.Overview.MessageOverview.request✝ o)) →
motive t | false |
natCast_eq_one | Mathlib.Algebra.Order.Kleene | ∀ {α : Type u_1} [inst : IdemSemiring α] {n : ℕ}, n ≠ 0 → ↑n = 1 | true |
CategoryTheory.Comma.unopFunctorCompFst | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
(L : CategoryTheory.Functor A T) →
(R : CategoryTheory.Functor B T) →
... | true |
Equiv.Set.powerset._proof_4 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_1} (S : Set α) (x : ↑(𝒫 S)), (fun x => ⟨Subtype.val '' x, ⋯⟩) ((fun x => Subtype.val ⁻¹' ↑x) x) = x | false |
Filter.image_mem_map_iff | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {s : Set α},
Function.Injective m → (m '' s ∈ Filter.map m f ↔ s ∈ f) | true |
Std.Time.Hour.Offset.ofDays | Std.Time.Date.Basic | Std.Time.Day.Offset → Std.Time.Hour.Offset | true |
Polynomial.coeff_mul_add_eq_of_natDegree_le | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : Semiring R] {df dg : ℕ} {f g : Polynomial R},
f.natDegree ≤ df → g.natDegree ≤ dg → (f * g).coeff (df + dg) = f.coeff df * g.coeff dg | true |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.get_EStateM._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) | false |
Units.Simps.val_inv.eq_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (u : αˣ), Units.Simps.val_inv u = ↑u⁻¹ | true |
Int8.toInt16_xor | Init.Data.SInt.Bitwise | ∀ (a b : Int8), (a ^^^ b).toInt16 = a.toInt16 ^^^ b.toInt16 | true |
_private.Init.Data.Array.Erase.0.Array.eraseIdx_set._proof_3 | Init.Data.Array.Erase | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {a : α} {hi : i < xs.size} {j : ℕ}, j < i → ¬i - 1 < xs.size - 1 → False | false |
Nat.add_div | Init.Data.Nat.Div.Lemmas | ∀ {a b c : ℕ}, 0 < c → (a + b) / c = a / c + b / c + if c ≤ a % c + b % c then 1 else 0 | true |
CategoryTheory.Limits.binaryFanZeroRightIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] (X : C)
(s : CategoryTheory.Limits.BinaryFan X 0),
CategoryTheory.CategoryStruct.comp ((fun s => s.fst) s) (CategoryTheory.CategoryStruct.id X) = s.fst | false |
AddMonoidAlgebra.toRingHom_mapRingEquiv | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : AddMonoid M]
(e : R ≃+* S), (AddMonoidAlgebra.mapRingEquiv M e).toRingHom = AddMonoidAlgebra.mapRingHom M ↑e | true |
Iff.mpr | Init.Core | ∀ {a b : Prop}, (a ↔ b) → b → a | true |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_25 | Mathlib.Data.List.Basic | ∀ {ι : Type u_1} [inst : BEq ι] (a : ι) (l : List ι) (n : ℕ) (w : ι)
(h : 1 ≤ (List.filter (fun x => x == w) (List.take (n + 1) (a :: l))).length),
(List.findIdxs (fun x => x == w) (List.take (n + 1) (a :: l)))[0] < (List.take (n + 1) (a :: l)).length | false |
Matrix.kroneckerMap_zero_left | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ {α : Type u_3} {β : Type u_5} {γ : Type u_7} {l : Type u_9} {m : Type u_10} {n : Type u_11} {p : Type u_12}
[inst : Zero α] [inst_1 : Zero γ] (f : α → β → γ),
(∀ (b : β), f 0 b = 0) → ∀ (B : Matrix n p β), Matrix.kroneckerMap f 0 B = 0 | true |
_private.Lean.Level.0.Lean.Level.isExplicitSubsumedAux | Lean.Level | Array Lean.Level → ℕ → ℕ → Bool | true |
_private.Lean.Meta.Sym.Simp.App.0.Lean.Meta.Sym.Simp.simpUsingCongrThm | Lean.Meta.Sym.Simp.App | Lean.Expr → Lean.Meta.CongrTheorem → Lean.Meta.Sym.Simp.SimpM Lean.Meta.Sym.Simp.Result | true |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.ofRestrict | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X : TopCat} (Y : AlgebraicGeometry.LocallyRingedSpace) {f : X ⟶ ↑Y.toPresheafedSpace}
(hf : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)),
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion (Y.ofRestrict hf) | true |
DividedPowers.coincide_on_smul | Mathlib.RingTheory.DividedPowers.Basic | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} {a : A} (hI : DividedPowers I) {J : Ideal A}
(hJ : DividedPowers J) {n : ℕ}, a ∈ I • J → hI.dpow n a = hJ.dpow n a | true |
_private.Qq.Macro.0.Qq.Impl.quoteLCtx.match_1 | Qq.Macro | (motive : MProd (Array Lean.Expr) Lean.LocalContext → Sort u_1) →
(r : MProd (Array Lean.Expr) Lean.LocalContext) →
((assignments : Array Lean.Expr) → (quotedCtx : Lean.LocalContext) → motive ⟨assignments, quotedCtx⟩) → motive r | false |
List.filterMapM.loop._sunfold | Init.Data.List.Control | {m : Type u → Type v} → [Monad m] → {α : Type w} → {β : Type u} → (α → m (Option β)) → List α → List β → m (List β) | false |
List.MergeSort.Internal.splitRevInTwo_fst._proof_1 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} {n : ℕ} (l : { l // l.length = n }),
(↑(List.MergeSort.Internal.splitInTwo l).1).reverse.length = (n + 1) / 2 | false |
Lean.Meta.Sym.Offset.num.elim | Lean.Meta.Sym.Offset | {motive : Lean.Meta.Sym.Offset → Sort u} →
(t : Lean.Meta.Sym.Offset) → t.ctorIdx = 0 → ((k : ℕ) → motive (Lean.Meta.Sym.Offset.num k)) → motive t | false |
CategoryTheory.Subgroupoid.instTop._proof_1 | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u_2} [inst : CategoryTheory.Groupoid C] {c d : C} {p : c ⟶ d},
p ∈ Set.univ → CategoryTheory.Groupoid.inv p ∈ Set.univ | false |
differentiableWithinAt_comp_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {s : Set E} (a : E),
DifferentiableWithinAt 𝕜 (fun x => f (x - a)) s x ↔ DifferentiableWi... | true |
CochainComplex.ConnectData.d_negSucc | Mathlib.Algebra.Homology.Embedding.Connect | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : ChainComplex C ℕ} {L : CochainComplex C ℕ} (h : CochainComplex.ConnectData K L) (n m : ℕ),
h.d (Int.negSucc n) (Int.negSucc m) = K.d n m | true |
Lean.Meta.Grind.SplitDiagInfo.c | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.SplitDiagInfo → Lean.Expr | true |
Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.toIntInst | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Lean.Meta.Grind.Arith.Cutsat.ToIntInfo → Lean.Expr | true |
Matrix.frobenius_norm_replicateRow | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_3} {α : Type u_5} {ι : Type u_7} [inst : Fintype m] [inst_1 : Unique ι]
[inst_2 : SeminormedAddCommGroup α] (v : m → α), ‖Matrix.replicateRow ι v‖ = ‖WithLp.toLp 2 v‖ | true |
AlgebraicGeometry.Scheme.Pullback.range_diagonal_subset_diagonalCoverDiagonalRange | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : Y.OpenCover)
(𝒱 : (i : 𝒰.I₀) → (CategoryTheory.Limits.pullback f (𝒰.f i)).OpenCover),
Set.range ⇑(CategoryTheory.Limits.pullback.diagonal f) ⊆
↑(AlgebraicGeometry.Scheme.Pullback.diagonalCoverDiagonalRange f 𝒰 𝒱) | true |
NonUnitalAlgebra.map_top | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : Module R B] [inst_5 : IsScalarTower R A A]
[inst_6 : SMulCommClass R A A] (f : A →ₙₐ[R] B), NonUnitalSubalgebra.map f ⊤ = NonUnitalAlgHom.ran... | true |
Lean.ImportArtifacts.size | Lean.Setup | Lean.ImportArtifacts → ℕ | true |
_private.Lean.Server.Requests.0.Lean.Server.chainLspRequestHandler.match_1 | Lean.Server.Requests | (motive : Option Lean.Json → Sort u_1) →
(x : Option Lean.Json) → (Unit → motive none) → ((response : Lean.Json) → motive (some response)) → motive x | false |
Lean.Elab.Tactic.MkSimpContextResult | Lean.Elab.Tactic.Simp | Type | true |
Lean.Linter.LinterOptions._sizeOf_1 | Lean.Linter.Basic | Lean.Linter.LinterOptions → ℕ | false |
AddGroupSeminorm.rec | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} →
[inst : AddGroup G] →
{motive : AddGroupSeminorm G → Sort u} →
((toFun : G → ℝ) →
(map_zero' : toFun 0 = 0) →
(add_le' : ∀ (r s : G), toFun (r + s) ≤ toFun r + toFun s) →
(neg' : ∀ (r : G), toFun (-r) = toFun r) →
motive { toFun := toFun, ... | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Basic.0.SimpleGraph.edgeDisjointTriangles_iff_mem_sym2_subsingleton._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Basic | ∀ {α : Type u_1} {s : Finset α} {m : Sym2 α}, (m ∈ s.sym2) = ∀ a ∈ m, a ∈ s | false |
Matroid.IsBasis.cardinalMk_le_cRk | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u} {M : Matroid α} {I X : Set α}, M.IsBasis I X → Cardinal.mk ↑I ≤ M.cRk X | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.