name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
String.Slice.eq_append_of_dropSuffix?_slice_eq_some | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {pat s res : String.Slice}, s.dropSuffix? pat = some res → s.copy = res.copy ++ pat.copy | true |
fderiv_const_smul_of_field | 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}
{R : Type u_4} [inst_5 : DivisionSemiring R] [inst_6 : Module R F] [inst_7 : SMulCommClass 𝕜 R F]
... | true |
Subgroup.index_top | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G], ⊤.index = 1 | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey_erase_le_maxKey._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
Lean.Parser.Tactic.generalize | Init.Tactics | Lean.ParserDescr | true |
Int32.toNat_toBitVec | Init.Data.SInt.Lemmas | ∀ (x : Int32), x.toBitVec.toNat = x.toUInt32.toNat | true |
_private.Mathlib.CategoryTheory.Sites.Types.0.CategoryTheory.typesGlue._simp_3 | Mathlib.CategoryTheory.Sites.Types | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) {X Y Z : C} (f : X ⟶ Y)
(g : Y ⟶ Z) (a : F.obj X), F.map g (F.map f a) = F.map (CategoryTheory.CategoryStruct.comp f g) a | false |
IsUniformInducing.completableTopField | Mathlib.Topology.Algebra.UniformField | ∀ {α : Type u_3} {β : Type u_4} [inst : Field β] [b : UniformSpace β] [CompletableTopField β] [inst_2 : Field α]
[inst_3 : UniformSpace α] [T0Space α] {f : α →+* β}, IsUniformInducing ⇑f → CompletableTopField α | true |
Algebra.traceForm_toMatrix | Mathlib.RingTheory.Trace.Defs | ∀ (R : Type u_1) {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {ι : Type w}
[inst_3 : Fintype ι] [inst_4 : DecidableEq ι] (b : Module.Basis ι R S) (i j : ι),
(LinearMap.BilinForm.toMatrix b) (Algebra.traceForm R S) i j = (Algebra.trace R S) (b i * b j) | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_474 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α),
List.findIdxNth (fun x => decide (x = w_1)) [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] [g (g a)].length) + 1 ≤
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.findIdxNth (fun x => decide (x = w_1))... | false |
Batteries.BinomialHeap.Imp.combine | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
(α → α → Bool) →
α →
α →
Batteries.BinomialHeap.Imp.HeapNode α →
Batteries.BinomialHeap.Imp.HeapNode α → α × Batteries.BinomialHeap.Imp.HeapNode α | true |
CategoryTheory.Arrow.AugmentedCechNerve.ExtraDegeneracy.s_comp_π_0 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (f : CategoryTheory.Arrow C)
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
(S : CategoryTheory.SplitEpi f.hom) (n : ℕ),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Arrow.AugmentedCechNerve.... | true |
IsWellFounded.induction | Mathlib.Order.RelClasses | ∀ {α : Type u} (r : α → α → Prop) [IsWellFounded α r] {motive : α → Prop} (a : α),
(∀ (x : α), (∀ (y : α), r y x → motive y) → motive x) → motive a | true |
Mathlib.Tactic.BicategoryLike.Normalize.instInhabitedResult.default | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | Mathlib.Tactic.BicategoryLike.Normalize.Result | true |
CStarMatrix.instUniformSpace._proof_4 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {A : Type u_2} [inst : NonUnitalCStarAlgebra A] {m : Type u_3} {n : Type u_1},
(CStarMatrix.instUniformSpace._aux_1.lift' fun s => SetRel.comp s s) ≤ CStarMatrix.instUniformSpace._aux_1 | false |
antilipschitzWith_lineMap | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ {W : Type u_3} {Q : Type u_4} [inst : NormedAddCommGroup W] [inst_1 : MetricSpace Q] [inst_2 : NormedAddTorsor W Q]
{𝕜 : Type u_5} [inst_3 : NormedField 𝕜] [inst_4 : NormedSpace 𝕜 W] {p₁ p₂ : Q},
p₁ ≠ p₂ → AntilipschitzWith (nndist p₁ p₂)⁻¹ ⇑(AffineMap.lineMap p₁ p₂) | true |
_private.Std.Internal.Http.Data.Body.Stream.0.Std.Http.Body.Channel.decreaseKnownSize._sparseCasesOn_2 | Std.Internal.Http.Data.Body.Stream | {motive : Std.Http.Body.Length → Sort u} →
(t : Std.Http.Body.Length) →
((n : ℕ) → motive (Std.Http.Body.Length.fixed n)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Int.mul_tmod_right | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), (a * b).tmod a = 0 | true |
CochainComplex.MappingConeCompHomotopyEquiv.homotopyInvHomId._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.Triangulated | -1 + -1 = -2 | false |
CategoryTheory.instIsConnectedWidePushoutShape | Mathlib.CategoryTheory.Limits.Shapes.Connected | ∀ {J : Type u_1}, CategoryTheory.IsConnected (CategoryTheory.Limits.WidePushoutShape J) | true |
CategoryTheory.Presheaf.restrictedULiftYonedaHomEquiv'_symm_app_naturality_left_assoc | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {ℰ : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} ℰ]
(A : CategoryTheory.Functor C ℰ) {P Q : CategoryTheory.Functor Cᵒᵖ (Type (max w v₁ v₂))} (f : P ⟶ Q) (E : ℰ)
(g : Q ⟶ (CategoryTheory.Presheaf.restrictedULiftYoneda A).obj E)
(p : CategoryTheory... | true |
PUnit.instCompleteAtomicBooleanAlgebra._proof_1 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {ι : Type u_1} {κ : ι → Type u_1} (x : (a : ι) → κ a → PUnit.{u_1 + 1}), ⨅ a, ⨆ b, x a b = ⨅ a, ⨆ b, x a b | false |
NumberField.instCommRingRingOfIntegers._proof_39 | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K],
autoParam (∀ (a : NumberField.RingOfIntegers K), NumberField.instCommRingRingOfIntegers._aux_37 K 0 a = 0)
SubNegMonoid.zsmul_zero'._autoParam | false |
ContinuousMap.rec | Mathlib.Topology.ContinuousMap.Defs | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{motive : C(X, Y) → Sort u} →
((toFun : X → Y) →
(continuous_toFun : Continuous toFun) → motive { toFun := toFun, continuous_toFun := continuous_toFun }) →
(t : C(X, Y)... | false |
CategoryTheory.CoreSmallCategoryOfSet.mk.inj | Mathlib.CategoryTheory.SmallRepresentatives | ∀ {Ω : Type w} {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {obj : Set Ω} {hom : ↑obj → ↑obj → Set Ω}
{objEquiv : ↑obj ≃ C} {homEquiv : {X Y : ↑obj} → ↑(hom X Y) ≃ (objEquiv X ⟶ objEquiv Y)} {obj_1 : Set Ω}
{hom_1 : ↑obj_1 → ↑obj_1 → Set Ω} {objEquiv_1 : ↑obj_1 ≃ C}
{homEquiv_1 : {X Y : ↑obj_1} → ↑(hom_... | true |
_private.Lean.Compiler.NameDemangling.0.Lean.Name.Demangle.SpecEntry.flags | Lean.Compiler.NameDemangling | Lean.Name.Demangle.SpecEntry✝ → Array String | true |
Nat.testBit_bitwise | Init.Data.Nat.Bitwise.Lemmas | ∀ {f : Bool → Bool → Bool},
f false false = false → ∀ (x y i : ℕ), (Nat.bitwise f x y).testBit i = f (x.testBit i) (y.testBit i) | true |
CategoryTheory.Functor.IsFibered.casesOn | Mathlib.CategoryTheory.FiberedCategory.Fibered | {𝒮 : Type u₁} →
{𝒳 : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳] →
{p : CategoryTheory.Functor 𝒳 𝒮} →
{motive : p.IsFibered → Sort u} →
(t : p.IsFibered) →
([toIsPreFibered : p.IsPreFibered] →
... | false |
FP.Float.noConfusionType | Mathlib.Data.FP.Basic | Sort u → [C : FP.FloatCfg] → FP.Float → [C' : FP.FloatCfg] → FP.Float → Sort u | false |
Lean.MonadQuotation.getContext | Init.Prelude | {m : Type → Type} → [self : Lean.MonadQuotation m] → m Lean.Name | true |
Lean.Lsp.DiagnosticTag.ctorElim | Lean.Data.Lsp.Diagnostics | {motive : Lean.Lsp.DiagnosticTag → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Lsp.DiagnosticTag) → ctorIdx = t.ctorIdx → Lean.Lsp.DiagnosticTag.ctorElimType ctorIdx → motive t | false |
EuclideanGeometry.Sphere.secondInter_mem | Mathlib.Geometry.Euclidean.Sphere.SecondInter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p : P} (v : V), s.secondInter p v ∈ s ↔ p ∈ s | true |
_private.Lean.Meta.Tactic.Grind.Attr.0.Lean.Meta.Grind.Extension.eraseCasesAttr | Lean.Meta.Tactic.Grind.Attr | Lean.Meta.Grind.Extension → Lean.Name → Lean.CoreM Unit | true |
BoxIntegral.TaggedPrepartition.tag | Mathlib.Analysis.BoxIntegral.Partition.Tagged | {ι : Type u_1} → {I : BoxIntegral.Box ι} → BoxIntegral.TaggedPrepartition I → BoxIntegral.Box ι → ι → ℝ | true |
instProperConstSMulForall | Mathlib.Topology.Algebra.ProperConstSMul | ∀ {M : Type u_1} {ι : Type u_2} {X : ι → Type u_3} [inst : (i : ι) → SMul M (X i)]
[inst_1 : (i : ι) → TopologicalSpace (X i)] [∀ (i : ι), ProperConstSMul M (X i)], ProperConstSMul M ((i : ι) → X i) | true |
div_div_div_cancel_left' | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {G₀ : Type u_3} [inst : CommGroupWithZero G₀] {c : G₀} (a b : G₀), c ≠ 0 → c / a / (c / b) = b / a | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.msb_allOnes._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, 2 ≤ 2 ^ w → ¬2 * (2 ^ w - 1) ≥ 2 ^ w → False | false |
CategoryTheory.ShortComplex.SnakeInput.composableArrowsFunctor._proof_4 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{X Y Z : CategoryTheory.ShortComplex.SnakeInput C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.ComposableArrows.homMk₅ (CategoryTheory.CategoryStruct.comp f g).f₀.τ₁
(CategoryTheory.CategoryStruct.comp f g).f₀.τ₂ (C... | false |
Finset.singleton_smul | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : SMul α β] {t : Finset β} (a : α), {a} • t = a • t | true |
List.filterMap_eq_map | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, List.filterMap (some ∘ f) = List.map f | true |
Std.ExtDHashMap.isSome_getKey?_eq_contains | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a : α}, (m.getKey? a).isSome = m.contains a | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey!_insertIfNew_le_self._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
_private.Mathlib.MeasureTheory.Measure.Haar.Unique.0.MeasureTheory.Measure.measure_isHaarMeasure_eq_smul_of_isEverywherePos._simp_1_12 | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_3} [inst : Group G] (a : G) (n : ℤ), a ^ n * a = a ^ (n + 1) | false |
CategoryTheory.InjectiveResolution.instQuasiIsoIntι' | Mathlib.CategoryTheory.Abelian.Injective.Extend | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X : C}
(R : CategoryTheory.InjectiveResolution X), QuasiIso R.ι' | true |
IsSolvableByRad.below.rec | Mathlib.FieldTheory.AbelRuffini | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
{motive : (a : E) → IsSolvableByRad F a → Prop}
{motive_1 : {a : E} → (t : IsSolvableByRad F a) → IsSolvableByRad.below t → Prop},
(∀ (α : F), motive_1 ⋯ ⋯) →
(∀ (α β : E) (a : IsSolvableByRad F α) (a_1 : IsSolvableByRa... | false |
Mathlib.Util.TermReduce.elabBeta | Mathlib.Util.TermReduce | Lean.Elab.Term.TermElab | true |
Matroid.ofExistsMatroid._proof_4 | Mathlib.Combinatorics.Matroid.IndepAxioms | ∀ {α : Type u_1} (E : Set α) (Indep : Set α → Prop),
(∃ M, E = M.E ∧ ∀ (I : Set α), M.Indep I ↔ Indep I) →
(∃ M, E = M.E ∧ M.Indep = Indep) →
∀ ⦃I B : Set α⦄, Indep I → ¬Maximal Indep I → Maximal Indep B → ∃ x ∈ B \ I, Indep (insert x I) | false |
pairwise_not_eq_iff_injective._simp_1 | Mathlib.Data.Set.Pairwise.Basic | ∀ {α : Type u_1} {ι : Type u_4} {f : ι → α}, (Pairwise fun i j => ¬f i = f j) = Function.Injective f | false |
_private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.evalIntCast._proof_1 | Mathlib.Tactic.Positivity.Basic | failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation) | false |
NonUnitalStarSubalgebra.range_val | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : StarRing A]
[inst_3 : Module R A] (S : NonUnitalStarSubalgebra R A),
NonUnitalStarAlgHom.range (NonUnitalStarSubalgebraClass.subtype S) = S | true |
CompHausLike.instHasPullbacksOfInclusionsOfHasExplicitPullbacksOfInclusions | Mathlib.Topology.Category.CompHausLike.Limits | ∀ {P : TopCat → Prop} [inst : CompHausLike.HasExplicitFiniteCoproducts P]
[CompHausLike.HasExplicitPullbacksOfInclusions P], CategoryTheory.HasPullbacksOfInclusions (CompHausLike P) | true |
_private.Init.Data.List.Control.0.List.findM?.eq_def | Init.Data.List.Control | ∀ {m : Type → Type u} [inst : Monad m] {α : Type} (p : α → m Bool) (x : List α),
List.findM? p x =
match x with
| [] => pure none
| a :: as => do
let __do_lift ← p a
match __do_lift with
| true => pure (some a)
| false => List.findM? p as | true |
_private.Lean.Compiler.LCNF.ExpandResetReuse.0.Lean.Compiler.LCNF.Code.expandResetReuse._sparseCasesOn_1 | Lean.Compiler.LCNF.ExpandResetReuse | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.LetValue pu → Sort u} →
(t : Lean.Compiler.LCNF.LetValue pu) →
((n : ℕ) →
(var : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive (Lean.Compiler.LCNF.LetValue.reset n var h)) →
(Nat.hasNotBit 204... | false |
instLinearOrderNNRat._aux_11 | Mathlib.Data.NNRat.Defs | ℚ≥0 → ℚ≥0 → ℚ≥0 | false |
Lean.Meta.Grind.Arith.CommRing.getAddFn | Lean.Meta.Tactic.Grind.Arith.CommRing.Functions | {m : Type → Type} →
[MonadLiftT Lean.MetaM m] →
[Lean.MonadError m] →
[Monad m] →
[Lean.Meta.Grind.Arith.CommRing.MonadCanon m] → [Lean.Meta.Grind.Arith.CommRing.MonadRing m] → m Lean.Expr | true |
OmegaCompletePartialOrder.Chain.map_toOrderHom | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (c : OmegaCompletePartialOrder.Chain α)
(f : α →o β), (c.map f).toOrderHom = f.comp c.toOrderHom | true |
Submonoid.opEquiv_symm_apply | Mathlib.Algebra.Group.Submonoid.MulOpposite | ∀ {M : Type u_2} [inst : MulOneClass M] (x : Submonoid Mᵐᵒᵖ), (RelIso.symm Submonoid.opEquiv) x = x.unop | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Decomp.0.SimpleGraph.Walk.dropUntil_eq_drop._proof_1_4 | Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | ∀ {V : Type u_1} {G : SimpleGraph V} {w u_1 : V}, w ∈ SimpleGraph.Walk.nil.support → G.Walk u_1 u_1 = G.Walk w u_1 | false |
CategoryTheory.Limits.Wedge.mk_ι | Mathlib.CategoryTheory.Limits.Shapes.End | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {C : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} C]
{F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)} (pt : C)
(π : (j : J) → pt ⟶ (F.obj (Opposite.op j)).obj j)
(hπ :
∀ ⦃i j : J⦄ (f : i ⟶ j),
CategoryTheory.CategoryStruct.comp... | true |
FiniteIndexNormalSubgroup.instSemilatticeSupFiniteIndexNormalSubgroup._proof_1 | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | ∀ {G : Type u_1} [inst : Group G] {x y : FiniteIndexNormalSubgroup G},
x.toSubgroup ≤ y.toSubgroup ↔ x.toSubgroup ≤ y.toSubgroup | false |
AddHom.map_mclosure | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] (f : M →ₙ+ N) (s : Set M),
AddSubsemigroup.map f (AddSubsemigroup.closure s) = AddSubsemigroup.closure (⇑f '' s) | true |
Lean.Linter.MissingDocs.lintEmptyNamed | Lean.Linter.MissingDocs | Lean.Syntax → String → Lean.Elab.Command.CommandElabM Unit | true |
_private.Lean.Compiler.LCNF.EmitC.0.Lean.Compiler.LCNF.emitTailCall.overwriteParam | Lean.Compiler.LCNF.EmitC | Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure) →
Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.impure) → Bool | true |
Sylow.directProductOfNormal._proof_6 | Mathlib.GroupTheory.Sylow | ∀ {G : Type u_1} [inst : Group G] (p : ℕ) (hp : p ∈ (Nat.card G).primeFactors), SubgroupClass (Sylow (↑⟨p, hp⟩) G) G | false |
CategoryTheory.GlueData.ι_jointly_surjective | Mathlib.CategoryTheory.GlueData | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C)
[inst_1 : CategoryTheory.Limits.HasMulticoequalizer D.diagram] (F : CategoryTheory.Functor C (Type v))
[CategoryTheory.Limits.PreservesColimit D.diagram.multispan F]
[∀ (i j k : D.J), CategoryTheory.Limits.PreservesLimit (C... | true |
_private.Mathlib.Analysis.Normed.Field.Approximation.0.Polynomial.exists_roots_norm_sub_lt_of_norm_coeff_sub_lt._simp_1_1 | Mathlib.Analysis.Normed.Field.Approximation | ∀ (x : ℝ) (n : ℕ), x ^ n = x ^ ↑n | false |
_private.Mathlib.RingTheory.UniqueFactorizationDomain.Defs.0.WfDvdMonoid.isRelPrime_of_no_irreducible_factors.match_1_1 | Mathlib.RingTheory.UniqueFactorizationDomain.Defs | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] (_z : α) (motive : (∃ i, Irreducible i ∧ i ∣ _z) → Prop)
(x : ∃ i, Irreducible i ∧ i ∣ _z), (∀ (i : α) (h1 : Irreducible i) (h2 : i ∣ _z), motive ⋯) → motive x | false |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.getElem?_toArray_rcc_eq_some_iff._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | false |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_ne_zero._simp_1_2 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u} [inst : Semiring R] [NoZeroDivisors R] {p : Polynomial R}, IsUnit p = ∃ r, IsUnit r ∧ Polynomial.C r = p | false |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabAppImplicitCore.match_3 | Lean.PrettyPrinter.Delaborator.Builtins | (motive : Lean.PrettyPrinter.Delaborator.AppImplicitArg → Sort u_1) →
(x : Lean.PrettyPrinter.Delaborator.AppImplicitArg) →
((name : Lean.Name) → (s : Lean.Term) → motive (Lean.PrettyPrinter.Delaborator.AppImplicitArg.optional name s)) →
((x : Lean.PrettyPrinter.Delaborator.AppImplicitArg) → motive x) → mot... | false |
ConjAct.smulCommClass' | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ (α : Type u_1) {G : Type u_3} [inst : Group G] [inst_1 : SMul α G] [SMulCommClass G α G] [IsScalarTower α G G],
SMulCommClass (ConjAct G) α G | true |
_private.Batteries.Data.List.Perm.0.List.subperm_append_left.match_1_1 | Batteries.Data.List.Perm | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (a : α) (l : List α), motive (a :: l)) → motive x | false |
Mathlib.Tactic._aux_Mathlib_Tactic_Basic___macroRules_Mathlib_Tactic_tacticAssumption'_1 | Mathlib.Tactic.Basic | Lean.Macro | false |
Std.DTreeMap.Raw.contains_map | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} {γ : α → Type w}
[Std.TransCmp cmp] {f : (a : α) → β a → γ a} {k : α}, t.WF → (Std.DTreeMap.Raw.map f t).contains k = t.contains k | true |
Char.reduceOfNatAux | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | Lean.Meta.Simp.DSimproc | true |
starL._proof_1 | Mathlib.Topology.Algebra.Module.Star | ∀ {A : Type u_1} [inst : AddCommMonoid A] [inst_1 : StarAddMonoid A] [inst_2 : TopologicalSpace A] [ContinuousStar A],
Continuous star | false |
Projectivization.lift._proof_1 | Mathlib.LinearAlgebra.Projectivization.Basic | ∀ {K : Type u_2} {V : Type u_1} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {α : Type u_3}
(f : { v // v ≠ 0 } → α),
(∀ (a b : { v // v ≠ 0 }) (t : K), ↑a = t • ↑b → f a = f b) → ∀ (a b : { v // v ≠ 0 }), a ≈ b → f a = f b | false |
MeasureTheory.L2.real_inner_indicatorConstLp_one_indicatorConstLp_one._auto_3 | Mathlib.MeasureTheory.Function.L2Space | Lean.Syntax | false |
Multiset.prod_eq_foldr | Mathlib.Algebra.BigOperators.Group.Multiset.Defs | ∀ {M : Type u_3} [inst : CommMonoid M] (s : Multiset M), s.prod = Multiset.foldr (fun x1 x2 => x1 * x2) 1 s | true |
DomMulAct.instMonoidOfMulOpposite.eq_1 | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} [inst : Monoid Mᵐᵒᵖ], DomMulAct.instMonoidOfMulOpposite = inst | true |
CategoryTheory.Iso.mk.noConfusion | Mathlib.CategoryTheory.Iso | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{X Y : C} →
{P : Sort u_1} →
{hom : X ⟶ Y} →
{inv : Y ⟶ X} →
{hom_inv_id :
autoParam (CategoryTheory.CategoryStruct.comp hom inv = CategoryTheory.CategoryStruct.id X)
CategoryTheory.Iso... | false |
Lean.Parser.Term.logNamedErrorAtMacro.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | true |
Nat.dvd_sub_self_right._simp_1 | Mathlib.Data.Nat.Basic | ∀ {n m : ℕ}, (n ∣ m - n) = (n ∣ m ∨ m ≤ n) | false |
Std.Sat.CNF.empty.eq_1 | Std.Sat.CNF.Basic | ∀ {α : Type u_1}, Std.Sat.CNF.empty = { clauses := #[] } | true |
CategoryTheory.Yoneda.isIso | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y)
[CategoryTheory.IsIso (CategoryTheory.yoneda.map f)], CategoryTheory.IsIso f | true |
CategoryTheory.FreeBicategory.normalizeIso | Mathlib.CategoryTheory.Bicategory.Coherence | {B : Type u} →
[inst : Quiver B] →
{a b c : B} →
(p : Quiver.Path a b) →
(f : CategoryTheory.FreeBicategory.Hom b c) →
CategoryTheory.CategoryStruct.comp ((CategoryTheory.FreeBicategory.preinclusion B).map { as := p }) f ≅
(CategoryTheory.FreeBicategory.preinclusion B).map { as... | true |
Orthonormal.enorm_eq_one | Mathlib.Analysis.InnerProductSpace.Orthonormal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} {v : ι → E}, Orthonormal 𝕜 v → ∀ (i : ι), ‖v i‖ₑ = 1 | true |
Field.embEquivOfAdjoinSplits._proof_1 | Mathlib.FieldTheory.SeparableDegree | ∀ (F : Type u_1) (E : Type u_2) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E], IsScalarTower F F E | false |
DerivedCategory.homologyFunctorFactors | Mathlib.Algebra.Homology.DerivedCategory.HomologySequence | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : HasDerivedCategory C] →
(n : ℤ) →
DerivedCategory.Q.comp (DerivedCategory.homologyFunctor C n) ≅
HomologicalComplex.homologyFunctor C (ComplexShape.up ℤ) n | true |
SummationFilter.instLeAtTopSymmetricIcc | Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : PartialOrder G] [IsOrderedAddMonoid G]
[inst_3 : LocallyFiniteOrder G], (SummationFilter.symmetricIcc G).LeAtTop | true |
AlgebraicGeometry.Scheme.Hom.isoOpensRange._proof_2 | Mathlib.AlgebraicGeometry.Restrict | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.IsOpenImmersion f],
AlgebraicGeometry.IsOpenImmersion (AlgebraicGeometry.Scheme.Hom.opensRange f).ι | false |
Std.DTreeMap.Raw.getEntryGED | Std.Data.DTreeMap.Raw.Basic | {α : Type u} →
{β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap.Raw α β cmp → α → (a : α) × β a → (a : α) × β a | true |
Lean.Elab.Term.StructInst.ExplicitSourceView.casesOn | Lean.Elab.StructInst | {motive : Lean.Elab.Term.StructInst.ExplicitSourceView → Sort u} →
(t : Lean.Elab.Term.StructInst.ExplicitSourceView) →
((stx : Lean.Syntax) →
(fvar : Lean.Expr) → (structName : Lean.Name) → motive { stx := stx, fvar := fvar, structName := structName }) →
motive t | false |
Std.Time.Internal.UnitVal.rec | Std.Time.Internal.UnitVal | {α : ℚ} →
{motive : Std.Time.Internal.UnitVal α → Sort u} →
((val : ℤ) → motive { val := val }) → (t : Std.Time.Internal.UnitVal α) → motive t | false |
IsDiscreteValuationRing.addVal_uniformizer | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] {ϖ : R},
Irreducible ϖ → (IsDiscreteValuationRing.addVal R) ϖ = 1 | true |
Filter.Tendsto.arccos_nhdsLE | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ {α : Type u_1} {l : Filter α} {x : ℝ} {f : α → ℝ},
Filter.Tendsto f l (nhdsWithin x (Set.Iic x)) →
Filter.Tendsto (fun x => Real.arccos (f x)) l (nhdsWithin (Real.arccos x) (Set.Ici (Real.arccos x))) | true |
TensorAlgebra.toDirectSum_comp_ofDirectSum | Mathlib.LinearAlgebra.TensorAlgebra.ToTensorPower | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
TensorAlgebra.toDirectSum.comp TensorAlgebra.ofDirectSum = AlgHom.id R (DirectSum ℕ fun n => TensorPower R n M) | true |
ZeroHom.instAddCommGroup._proof_1 | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type u_1} {N : Type u_2} [inst : Zero M] [inst_1 : AddCommGroup N] (a b : ZeroHom M N), a + b = b + a | false |
_private.Mathlib.Data.List.Sym.0.List.dedup_sym2._simp_1_4 | Mathlib.Data.List.Sym | ∀ {α : Type u_1} {xs : List α} {z : Sym2 α}, (z ∈ xs.sym2) = ∀ y ∈ z, y ∈ xs | false |
Tropical.trop_injective | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u}, Function.Injective Tropical.trop | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.