name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.revMatchesAt_iff._simp_1_2 | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos pos' : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatchAt c pos pos' =
∃ (h : pos' ≠ s.startPos), pos = pos'.prev h ∧ (pos'.prev h).get ⋯ = c | false |
AddSubmonoid.vaddCommClass_right | Mathlib.Algebra.Group.Submonoid.MulAction | ∀ {M' : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddZeroClass M'] [inst_1 : VAdd α β] [inst_2 : VAdd M' β]
[VAddCommClass α M' β] (S : AddSubmonoid M'), VAddCommClass α (↥S) β | true |
UInt32.neg_one_shiftLeft_and_shiftLeft | Init.Data.UInt.Bitwise | ∀ {a b : UInt32}, (-1) <<< b &&& a <<< b = a <<< b | true |
String.Pos.Raw.get.eq_1 | Batteries.Data.String.Legacy | ∀ (s : String) (p : String.Pos.Raw), String.Pos.Raw.get s p = String.Pos.Raw.utf8GetAux s.toList 0 p | true |
CliffordAlgebra.star_smul | Mathlib.LinearAlgebra.CliffordAlgebra.Star | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (r : R) (x : CliffordAlgebra Q), star (r • x) = r • star x | true |
Finset.mulEnergy_self_pos_iff | Mathlib.Combinatorics.Additive.Energy | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Mul α] {s : Finset α}, 0 < s.mulEnergy s ↔ s.Nonempty | true |
List.infix_cons_iff | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ : List α} {a : α} {l₂ : List α}, l₁ <:+: a :: l₂ ↔ l₁ <+: a :: l₂ ∨ l₁ <:+: l₂ | true |
Lean.Meta.Grind.Arith.CommRing.CommRing.fieldInst? | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Lean.Meta.Grind.Arith.CommRing.CommRing → Option Lean.Expr | true |
CategoryTheory.op_inv._simp_1 | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [inst_1 : CategoryTheory.IsIso f],
CategoryTheory.inv f.op = (CategoryTheory.inv f).op | false |
CategoryTheory.Sieve.fullyFaithfulFunctorGaloisCoinsertion | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) →
[F.Full] →
[F.Faithful] →
(X : C) →
GaloisCoinsertion (CategoryTheory.Sieve.functorPush... | true |
RingCat.Colimits.coconeMorphism | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J RingCat) → (j : J) → F.obj j ⟶ RingCat.Colimits.colimit F | true |
Cardinal.isRegular_aleph0 | Mathlib.SetTheory.Cardinal.Regular | Cardinal.aleph0.IsRegular | true |
Submodule.topologicalClosure_map | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
[inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂] [inst_8 : RingHomSurje... | true |
Std.Iter.Total.mk.injEq | Init.Data.Iterators.Consumers.Total | ∀ {α β : Type w} (it it_1 : Std.Iter β), ({ it := it } = { it := it_1 }) = (it = it_1) | true |
Function.eq_update_iff | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {β : α → Sort v} [inst : DecidableEq α] {a : α} {b : β a} {f g : (a : α) → β a},
g = Function.update f a b ↔ g a = b ∧ ∀ (x : α), x ≠ a → g x = f x | true |
Complex.sinh_add | Mathlib.Analysis.Complex.Trigonometric | ∀ (x y : ℂ), Complex.sinh (x + y) = Complex.sinh x * Complex.cosh y + Complex.cosh x * Complex.sinh y | true |
HasSum.of_subsingleton_cod | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α}
{L : SummationFilter β} [Subsingleton α], HasSum f 0 L | true |
CategoryTheory.Functor.LocallyCoverDense.functorPushforward_functorPullback_mem | Mathlib.CategoryTheory.Sites.DenseSubsite.InducedTopology | ∀ {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} {G : CategoryTheory.Functor C D}
{K : CategoryTheory.GrothendieckTopology D} [self : G.LocallyCoverDense K] ⦃X : C⦄ (T : ↑(K (G.obj X))),
CategoryTheory.Sieve.functorPushforward G (Categor... | true |
AddCon.instFunLikeForallProp.eq_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M], AddCon.instFunLikeForallProp = { coe := fun c => ⇑c.toSetoid, coe_injective' := ⋯ } | true |
Real.isGLB_sInf | Mathlib.Data.Real.Archimedean | ∀ {s : Set ℝ}, s.Nonempty → BddBelow s → IsGLB s (sInf s) | true |
Lean.Lsp.LeanLocationLink.mk.injEq | Lean.Data.Lsp.Internal | ∀ (toLocationLink : Lean.Lsp.LocationLink) (ident? : Option Lean.Lsp.LeanDeclIdent) (isDefault : Bool)
(toLocationLink_1 : Lean.Lsp.LocationLink) (ident?_1 : Option Lean.Lsp.LeanDeclIdent) (isDefault_1 : Bool),
({ toLocationLink := toLocationLink, ident? := ident?, isDefault := isDefault } =
{ toLocationLink ... | true |
Finpartition.indiscrete._proof_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] {a : α}, {a}.sup id = id a | false |
intervalIntegral.integral_hasDerivAt_right | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E} {a b : ℝ},
IntervalIntegrable f MeasureTheory.volume a b →
StronglyMeasurableAtFilter f (nhds b) MeasureTheory.volume →
ContinuousAt f b → HasDerivAt (fun u => ∫ (x : ℝ) in a..u, f x) (f b) b | true |
AddMonoid.Coprod.inl._proof_1 | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N],
AddMonoid.Coprod.mk (FreeAddMonoid.of (Sum.inl 0)) = AddMonoid.Coprod.mk 0 | false |
_private.Lean.Widget.InteractiveCode.0.Lean.Widget.instFromJsonDiffTag.fromJson.match_1 | Lean.Widget.InteractiveCode | (motive : String → Sort u_1) →
(tag : String) →
(Unit → motive "willInsert") →
(Unit → motive "wasChanged") →
(Unit → motive "willChange") →
(Unit → motive "wasDeleted") →
(Unit → motive "willDelete") → (Unit → motive "wasInserted") → ((x : String) → motive x) → motive tag | false |
isRegular_star_iff._simp_1 | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : Mul R] [inst_1 : StarMul R] {x : R}, IsRegular (star x) = IsRegular x | false |
Std.DTreeMap.Internal.Impl.getEntryGT?_eq_getEntryGT?ₘ' | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α) (t : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.getEntryGT? k t = Std.DTreeMap.Internal.Impl.getEntryGT?ₘ' k t | true |
_private.Mathlib.Data.ZMod.Defs.0.Fin.left_distrib_aux | Mathlib.Data.ZMod.Defs | ∀ (n : ℕ) (a b c : Fin n), a * (b + c) = a * b + a * c | true |
WellFoundedRelation.asymmetric₃._unary | Mathlib.Order.RelClasses | ∀ {α : Sort u_1} [inst : WellFoundedRelation α]
(_x :
(a : α) ×'
(b : α) ×'
(c : α) ×'
(_ : WellFoundedRelation.rel a b) ×' (_ : WellFoundedRelation.rel b c) ×' WellFoundedRelation.rel c a),
False | false |
String.Pos.Raw.instToIntCiOfNatInt._proof_3 | Init.Data.String.OrderInstances | ∀ (p q : String.Pos.Raw), ↑p.byteIdx = ↑q.byteIdx → p = q | false |
CategoryTheory.FreeMonoidalCategory.normalizeObj._sunfold | Mathlib.CategoryTheory.Monoidal.Free.Coherence | {C : Type u} →
CategoryTheory.FreeMonoidalCategory C →
CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C →
CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C | false |
Group.ResiduallyFinite | Mathlib.GroupTheory.ResiduallyFinite | (G : Type u_1) → [Group G] → Prop | true |
_private.Init.Data.SInt.Lemmas.0.Int16.ofNat_mul._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, Int16.ofNat n = Int16.ofInt ↑n | false |
Real.rpow_one_sub' | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x y : ℝ}, 0 ≤ x → 1 - y ≠ 0 → x ^ (1 - y) = x / x ^ y | true |
Orientation.areaForm_to_volumeForm | Mathlib.Analysis.InnerProductSpace.TwoDim | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : Fact (Module.finrank ℝ E = 2)]
(o : Orientation ℝ E (Fin 2)) (x y : E), (o.areaForm x) y = o.volumeForm ![x, y] | true |
_private.Mathlib.Algebra.FiniteSupport.Basic.0.Function.HasFiniteMulSupport.inf'._simp_1_1 | Mathlib.Algebra.FiniteSupport.Basic | ∀ {ι : Type u_1} {M : Type u_3} [inst : One M] {f : ι → M} {x : ι}, (x ∈ Function.mulSupport f) = (f x ≠ 1) | false |
even_iff_exists_two_mul | Mathlib.Algebra.Ring.Parity | ∀ {α : Type u_2} [inst : Semiring α] {a : α}, Even a ↔ ∃ b, a = 2 * b | true |
sum_mul_eq_sub_integral_mul₁ | Mathlib.NumberTheory.AbelSummation | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] (c : ℕ → 𝕜) {f : ℝ → 𝕜},
c 0 = 0 →
c 1 = 0 →
∀ (b : ℝ),
(∀ t ∈ Set.Icc 2 b, DifferentiableAt ℝ f t) →
MeasureTheory.IntegrableOn (deriv f) (Set.Icc 2 b) MeasureTheory.volume →
∑ k ∈ Finset.Icc 0 ⌊b⌋₊, f ↑k * c k =
f b * ∑ k ∈... | true |
CategoryTheory.ObjectProperty.extensionProductIter_le_of_isTriangulatedClosed₂ | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryT... | true |
IntermediateField.Lifts._sizeOf_inst | Mathlib.FieldTheory.Extension | (F : Type u_1) →
(E : Type u_2) →
(K : Type u_3) →
{inst : Field F} →
{inst_1 : Field E} →
{inst_2 : Field K} →
{inst_3 : Algebra F E} →
{inst_4 : Algebra F K} → [SizeOf F] → [SizeOf E] → [SizeOf K] → SizeOf (IntermediateField.Lifts F E K) | false |
AddMonoidAlgebra.liftNC_single | Mathlib.Algebra.MonoidAlgebra.Lift | ∀ {k : Type u₁} {G : Type u₂} {R : Type u_2} [inst : Semiring k] [inst_1 : NonUnitalNonAssocSemiring R] (f : k →+ R)
(g : Multiplicative G → R) (a : G) (b : k),
(AddMonoidAlgebra.liftNC f g) (AddMonoidAlgebra.single a b) = f b * g (Multiplicative.ofAdd a) | true |
Lean.Syntax.matchesLit | Init.Prelude | Lean.Syntax → Lean.SyntaxNodeKind → String → Bool | true |
CliffordAlgebraComplex.ofComplex | Mathlib.LinearAlgebra.CliffordAlgebra.Equivs | ℂ →ₐ[ℝ] CliffordAlgebra CliffordAlgebraComplex.Q | true |
Lean.Server.FileWorker.setupImports | Lean.Server.FileWorker | Lean.Server.DocumentMeta →
Lean.Options →
Std.Channel Lean.Server.FileWorker.OutputMessage →
Lean.Elab.HeaderSyntax →
Lean.Language.ProcessingT IO
(Except Lean.Language.Lean.HeaderProcessedSnapshot Lean.Language.Lean.SetupImportsResult) | true |
ContMDiffWithinAt.insert | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
Rack.selfApplyEquiv | Mathlib.Algebra.Quandle | (R : Type u_2) → [Rack R] → R ≃ R | true |
Function.Odd.map_zero | Mathlib.Algebra.Group.EvenFunction | ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommGroup β] [IsAddTorsionFree β] {f : α → β} [inst_2 : NegZeroClass α],
Function.Odd f → f 0 = 0 | true |
Rack.invAct_act_eq | Mathlib.Algebra.Quandle | ∀ {R : Type u_1} [inst : Rack R] (x y : R), Rack.invAct x (Shelf.act x y) = y | true |
RelSeries.Equiv._proof_5 | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (x : ↑{x | x ≠ [] ∧ List.IsChain (fun x1 x2 => (x1, x2) ∈ r) x}),
(fun x => ⟨x.toList, ⋯⟩) ((fun x => RelSeries.fromListIsChain ↑x ⋯ ⋯) x) = x | false |
Submodule.le_linearEquiv_of_sSup_eq_top | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (N : Submodule R M)
[IsSimpleModule R ↥N] (s : Set (Submodule R M)) [IsSemisimpleModule R M],
sSup s = ⊤ → ∃ m ∈ s, ∃ S ≤ m, Nonempty (↥N ≃ₗ[R] ↥S) | true |
Int.ModEq.multisetProd_map | Mathlib.Algebra.BigOperators.ModEq | ∀ {α : Type u_1} {n : ℤ} {f g : α → ℤ} {s : Multiset α},
(∀ x ∈ s, f x ≡ g x [ZMOD n]) → (Multiset.map f s).prod ≡ (Multiset.map g s).prod [ZMOD n] | true |
_private.Lean.Compiler.LCNF.ToMono.0.Lean.Compiler.LCNF.Code.toMono._sparseCasesOn_7 | Lean.Compiler.LCNF.ToMono | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo val)) →
(Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | false |
Finite.exists_le_minimal | Mathlib.Order.Preorder.Finite | ∀ {α : Type u_2} [inst : Preorder α] [Finite α] {p : α → Prop} {a : α}, p a → ∃ b ≤ a, Minimal p b | true |
IsPrimitiveRoot.associated_pow_sub_one_pow_of_coprime | Mathlib.RingTheory.RootsOfUnity.CyclotomicUnits | ∀ {n i j : ℕ} {A : Type u_1} {ζ : A} [inst : CommRing A] [IsDomain A],
IsPrimitiveRoot ζ n → i.Coprime n → j.Coprime n → Associated (ζ ^ j - 1) (ζ ^ i - 1) | true |
Lean.Elab.InlayHintKind.parameter.elim | Lean.Elab.InfoTree.InlayHints | {motive : Lean.Elab.InlayHintKind → Sort u} →
(t : Lean.Elab.InlayHintKind) → t.ctorIdx = 1 → motive Lean.Elab.InlayHintKind.parameter → motive t | false |
Ring.KrullDimLE.mem_minimalPrimes_iff | Mathlib.RingTheory.KrullDimension.Zero | ∀ {R : Type u_1} [inst : CommSemiring R] [Ring.KrullDimLE 0 R] {I J : Ideal R}, I ∈ J.minimalPrimes ↔ I.IsPrime ∧ J ≤ I | true |
instOrderTopSubtypeIsIdempotentElem._proof_2 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {M : Type u_1} [inst : CommMonoid M] (x : { a // IsIdempotentElem a }), ↑x * 1 = ↑x | false |
UInt16.and_eq_neg_one_iff | Init.Data.UInt.Bitwise | ∀ {a b : UInt16}, a &&& b = -1 ↔ a = -1 ∧ b = -1 | true |
UniversalEnvelopingAlgebra.Rel.recOn | Mathlib.Algebra.Lie.UniversalEnveloping | ∀ {R : Type u₁} {L : Type u₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
{motive : (a a_1 : TensorAlgebra R L) → UniversalEnvelopingAlgebra.Rel R L a a_1 → Prop} {a a_1 : TensorAlgebra R L}
(t : UniversalEnvelopingAlgebra.Rel R L a a_1),
(∀ (x y : L),
motive ((TensorAlgebra.ι R) ⁅x, ... | false |
unitary.mapEquiv | Mathlib.Algebra.Star.Unitary | {R : Type u_2} →
{S : Type u_3} →
[inst : Monoid R] →
[inst_1 : StarMul R] → [inst_2 : Monoid S] → [inst_3 : StarMul S] → (R ≃⋆* S) → ↥(unitary R) ≃⋆* ↥(unitary S) | true |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.analyze.analyzeLam | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM Unit | true |
Module.FinitePresentation.exists_lift_of_isLocalizedModule | Mathlib.Algebra.Module.FinitePresentation | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {N' : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] [inst_5 : AddCommGroup N']
[inst_6 : Module R N'] (S : Submonoid R) (f : N →ₗ[R] N') [IsLocalizedModule S f] [h : Module.FinitePresentati... | true |
LinearMap.prod_apply | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} {M₃ : Type y} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module R M₂]
[inst_6 : Module R M₃] (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) (i : M), (f.prod g) i = Pi.prod (⇑f) (⇑g) i | true |
Fin.exists_fin_zero_pi | Mathlib.Data.Fin.Tuple.Basic | ∀ {α : Fin 0 → Sort u_1} {P : ((i : Fin 0) → α i) → Prop}, (∃ x, P x) ↔ P finZeroElim | true |
Real.sign_eq_zero_iff | Mathlib.Data.Real.Sign | ∀ {r : ℝ}, r.sign = 0 ↔ r = 0 | true |
Algebra.Generators.equivH1Cotangent | Mathlib.RingTheory.Extension.Cotangent.Basic | {R : Type u} →
{S : Type v} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{ι : Type w} → (P : Algebra.Generators R S ι) → P.toExtension.H1Cotangent ≃ₗ[S] Algebra.H1Cotangent R S | true |
Homeomorph.smulOfNeZero._proof_1 | Mathlib.Topology.Algebra.ConstMulAction | ∀ {α : Type u_2} {G₀ : Type u_1} [inst : TopologicalSpace α] [inst_1 : GroupWithZero G₀] [inst_2 : MulAction G₀ α]
[ContinuousConstSMul G₀ α], ContinuousConstSMul G₀ˣ α | false |
CategoryTheory.Limits.limitCompWhiskeringLeftIsoCompLimit._proof_4 | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_5}
[inst_1 : CategoryTheory.Category.{u_6, u_5} D] {J : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} J]
{K : Type u_7} [inst_3 : CategoryTheory.Category.{u_8, u_7} K]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) (G... | false |
CategoryTheory.ShortComplex.Exact.fIsKernel._proof_1 | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C} (this : S.HasHomology) (this_1 : CategoryTheory.IsIso S.toCycles),
CategoryTheory.CategoryStruct.comp (CategoryTheory.asIso S.toCycles).symm.hom
(CategoryTheory.Limits.For... | false |
Minimal.and_right | Mathlib.Order.Minimal | ∀ {α : Type u_2} {P Q : α → Prop} {x : α} [inst : LE α], Minimal P x → Q x → Minimal (fun x => P x ∧ Q x) x | true |
_private.Init.Data.List.ToArray.0.List.findFinIdx?_loop_toArray._proof_1_3 | Init.Data.List.ToArray | ∀ {α : Type u_1} {j : ℕ} {l : List α} (l' : List α) {h : l'.length + 1 + j = l.length},
¬l.length - (j + 1) < l.length - j → False | false |
_private.Lean.Meta.Constructions.BRecOn.0.Lean.mkBelowFromRec._sparseCasesOn_4 | Lean.Meta.Constructions.BRecOn | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
USize.toUInt16_mod_of_dvd | Init.Data.UInt.Lemmas | ∀ (a b : USize), b.toNat ∣ 65536 → (a % b).toUInt16 = a.toUInt16 % b.toUInt16 | true |
ProperCone | Mathlib.Analysis.Convex.Cone.Basic | (R : Type u_2) →
(E : Type u_3) →
[inst : Semiring R] →
[inst_1 : PartialOrder R] →
[IsOrderedRing R] → [inst_3 : AddCommMonoid E] → [TopologicalSpace E] → [Module R E] → Type u_3 | true |
CategoryTheory.Limits.IsColimit.mk.noConfusion | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} J} →
{C : Type u₃} →
{inst_1 : CategoryTheory.Category.{v₃, u₃} C} →
{F : CategoryTheory.Functor J C} →
{t : CategoryTheory.Limits.Cocone F} →
{P : Sort u} →
{desc : (s : CategoryTheory.Limits.Cocone F) → t.... | false |
Std.Http.Header.ContentLength._sizeOf_1 | Std.Internal.Http.Data.Headers.Basic | Std.Http.Header.ContentLength → ℕ | false |
BoxIntegral.unitPartition.eq_of_mem_smul_span_of_index_eq_index | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} (n : ℕ) [NeZero n] [inst : Finite ι] {x y : ι → ℝ},
x ∈ (↑n)⁻¹ • Submodule.span ℤ (Set.range ⇑(Pi.basisFun ℝ ι)) →
y ∈ (↑n)⁻¹ • Submodule.span ℤ (Set.range ⇑(Pi.basisFun ℝ ι)) →
BoxIntegral.unitPartition.index n x = BoxIntegral.unitPartition.index n y → x = y | true |
CategoryTheory.ShortComplex.LeftHomologyMapData.neg._proof_6 | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {h₁ : S₁.LeftHomologyData} {h₂ : S₂.LeftHomologyData}
(γ : CategoryTheory.ShortComplex.LeftHomologyMapData φ h₁ h₂),
CategoryTheory.CategoryStruct.comp h₁.π ... | false |
_private.Mathlib.AlgebraicGeometry.Restrict.0.AlgebraicGeometry.morphismRestrict_comp._simp_1_1 | Mathlib.AlgebraicGeometry.Restrict | ∀ {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 |
cfc_comp_pow._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
_private.Mathlib.RingTheory.IntegralDomain.0.sum_hom_units_eq_zero._simp_1_1 | Mathlib.RingTheory.IntegralDomain | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | false |
NonUnitalSubsemiring.instTop._proof_2 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R], 0 ∈ ⊤.carrier | false |
Int.fract_zero | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] [IsOrderedRing R], Int.fract 0 = 0 | true |
Aesop.RuleSetNameFilter.matchesAll | Aesop.RuleSet.Filter | Aesop.RuleSetNameFilter → Bool | true |
_private.Mathlib.Tactic.ProxyType.0.Mathlib.ProxyType.defaultMkCtorProxyType._sparseCasesOn_3 | Mathlib.Tactic.ProxyType | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Equivalence.mk | Init.Core | ∀ {α : Sort u} {r : α → α → Prop},
(∀ (x : α), r x x) → (∀ {x y : α}, r x y → r y x) → (∀ {x y z : α}, r x y → r y z → r x z) → Equivalence r | true |
Mathlib.Explode.Entry.line._default | Mathlib.Tactic.Explode.Datatypes | Option ℕ | false |
UniformFun.continuousSMul_induced_of_range_bounded | Mathlib.Topology.Algebra.Module.UniformConvergence | ∀ (𝕜 : Type u_1) (α : Type u_2) (E : Type u_3) (H : Type u_4) {hom : Type u_5} [inst : NormedField 𝕜]
[inst_1 : AddCommGroup H] [inst_2 : Module 𝕜 H] [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E]
[inst_5 : TopologicalSpace H] [inst_6 : UniformSpace E] [IsUniformAddGroup E] [ContinuousSMul 𝕜 E]
[inst_9 : Fu... | true |
Lean.Meta.ppExprWithInfos | Lean.Meta.Basic | Lean.Expr → Lean.MetaM Lean.FormatWithInfos | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.KInjective.0.CochainComplex.isKInjective_of_injective._proof_1_3 | Mathlib.Algebra.Homology.HomotopyCategory.KInjective | ∀ (d : ℤ) (k : ℕ) (p q : ℤ), p + -1 = q → p ≤ d + ↑k → ¬p = ↑k + d - 1 + 2 | false |
MonoidHom.fiberEquivKer_apply | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {H : Type u_2} [inst_1 : Group H] (f : α →* H) (a : α) (g : ↑(⇑f ⁻¹' {f a})),
↑((f.fiberEquivKer a) g) = a⁻¹ * ↑g | true |
CategoryTheory.OrthogonalReflection.D₁ | Mathlib.CategoryTheory.Presentable.OrthogonalReflection | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.MorphismProperty C → C → Type (max u v) | true |
Submonoid.equivMapOfInjective | Mathlib.Algebra.Group.Submonoid.Operations | {N : Type u_2} →
[inst : MulOneClass N] →
{M : Type u_5} →
[inst_1 : MulOneClass M] → (S : Submonoid M) → (f : M →* N) → Function.Injective ⇑f → ↥S ≃* ↥(Submonoid.map f S) | true |
LieModule.disjoint_genWeightSpaceOf | Mathlib.Algebra.Lie.Weights.Basic | ∀ (R : Type u_2) (L : Type u_3) (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] [IsDomain R] [Module.IsTorsionFree R M] {x : L} {φ₁ φ₂ : R},
φ₁... | true |
_private.Lean.Elab.Tactic.Grind.Main.0.Lean.Elab.Tactic.elabGrindPattern.elabNotDefEq | Lean.Elab.Tactic.Grind.Main | Array Lean.Expr → Lean.Syntax → Lean.Syntax → Lean.Elab.TermElabM Lean.Meta.Grind.EMatchTheoremConstraint | true |
Convex.convex_isRCLikeNormedField | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedSpace ℝ E] [h : IsRCLikeNormedField 𝕜] {s : Set E}, Convex ℝ s → Convex ℝ s | true |
HasDerivAt.ccosh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {f : ℂ → ℂ} {f' x : ℂ}, HasDerivAt f f' x → HasDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) * f') x | true |
CategoryTheory.Iso.toIsometryEquiv_trans | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | ∀ {R : Type u} [inst : CommRing R] {X Y Z : QuadraticModuleCat R} (e : X ≅ Y) (f : Y ≅ Z),
(e ≪≫ f).toIsometryEquiv = e.toIsometryEquiv.trans f.toIsometryEquiv | true |
VAdd.noConfusionType | Mathlib.Algebra.Notation.Defs | Sort u_1 → {G : Type u} → {P : Type v} → VAdd G P → {G' : Type u} → {P' : Type v} → VAdd G' P' → Sort u_1 | false |
Filter.liminf_le_iff'._auto_1 | Mathlib.Order.LiminfLimsup | Lean.Syntax | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.