name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Algebra.Group.WithOne.Defs.0.WithOne.instSubsingletonOfIsEmpty._proof_1 | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u_1} [IsEmpty α], Subsingleton (WithOne α) | null | false |
MeasureTheory.SimpleFunc.pow_apply | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Monoid β] (n : ℕ)
(f : MeasureTheory.SimpleFunc α β) (a : α), (f ^ n) a = f a ^ n | null | true |
continuousSMul_closedBall_ball | Mathlib.Analysis.Normed.Module.Ball.Action | ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
{r : ℝ}, ContinuousSMul ↑(Metric.closedBall 0 1) ↑(Metric.ball 0 r) | null | true |
Set.sUnion_sub | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_1} [inst : Sub α] (S : Set (Set α)) (t : Set α), ⋃₀ S - t = ⋃ s ∈ S, s - t | null | true |
BitVec.getMsbD_rotateLeft | Init.Data.BitVec.Lemmas | ∀ {r n w : ℕ} {x : BitVec w}, (x.rotateLeft r).getMsbD n = (decide (n < w) && x.getMsbD ((r + n) % w)) | null | true |
CommSemiRingCat.Hom.hom | Mathlib.Algebra.Category.Ring.Basic | {R S : CommSemiRingCat} → R.Hom S → ↑R →+* ↑S | Turn a morphism in `CommSemiRingCat` back into a `RingHom`. | true |
Submodule.Quotient.equiv._proof_1 | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_1} [inst : Ring R] {R₂ : Type u_2} [inst_1 : Ring R₂] {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R}
[RingHomInvPair σ₁₂ σ₂₁], RingHomSurjective σ₁₂ | null | false |
CategoryTheory.Limits.createsFiniteLimitsOfCreatesFiniteLimitsOfSize | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | {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) →
{x : CategoryTheory.SmallCategory J} →
CategoryTheory.FinCategory J → CategoryTheor... | If `F` creates finite limits in any universe, then it creates finite limits. | true |
CategoryTheory.Equivalence.enoughProjectives_iff | Mathlib.CategoryTheory.Preadditive.Projective.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(F : C ≌ D), CategoryTheory.EnoughProjectives C ↔ CategoryTheory.EnoughProjectives D | null | true |
_private.Mathlib.CategoryTheory.Shift.ShiftedHomOpposite.0.CategoryTheory.ShiftedHom.opEquiv_symm_comp._proof_1 | Mathlib.CategoryTheory.Shift.ShiftedHomOpposite | ∀ {a b c : ℤ}, b + a = c → a + b = c | null | false |
Nat.getElem_toArray_roc | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ} (_h : i < (m<...=n).toArray.size), (m<...=n).toArray[i] = m + 1 + i | null | true |
Lean.Compiler.LCNF.instInhabitedSpecEntry | Lean.Compiler.LCNF.SpecInfo | Inhabited Lean.Compiler.LCNF.SpecEntry | null | true |
_private.Mathlib.GroupTheory.DivisibleHull.0.«term↑ⁿ» | Mathlib.GroupTheory.DivisibleHull | Lean.ParserDescr | null | true |
Left.one_lt_mul | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b c : α} [inst : MulOneClass α] [inst_1 : Preorder α] [MulLeftStrictMono α],
b < c → 1 < a → b < c * a | Assumes left covariance.
The lemma assuming right covariance is `Right.one_lt_mul`. | true |
_private.Init.Data.String.Basic.0.String.Slice.Pos.next_eq_nextFast._proof_1_7 | Init.Data.String.Basic | ∀ (s : String.Slice) (pos : s.Pos) (h : pos ≠ s.endPos),
¬pos.offset.byteIdx + (pos.str.get ⋯).utf8Size =
s.startInclusive.offset.byteIdx + pos.offset.byteIdx + (pos.str.get ⋯).utf8Size -
s.startInclusive.offset.byteIdx →
False | null | false |
NormedField.toNormedSpace._proof_1 | Mathlib.Analysis.Normed.Module.Basic | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] (a b : 𝕜), ‖a * b‖ ≤ ‖a‖ * ‖b‖ | null | false |
USize.ofNatLT_sub | Init.Data.UInt.Lemmas | ∀ {a b : ℕ} (ha : a < 2 ^ System.Platform.numBits) (hab : b ≤ a),
USize.ofNatLT (a - b) ⋯ = USize.ofNatLT a ha - USize.ofNatLT b ⋯ | null | true |
SimpleGraph.Subgraph.instDecidableRel_deleteVerts_adj._proof_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (u : Set V) (x : ↑(⊤.deleteVerts u).verts), ↑x ∈ ⊤.verts | null | false |
Lean.Grind.AC.SubseqResult.false.sizeOf_spec | Lean.Meta.Tactic.Grind.AC.Seq | sizeOf Lean.Grind.AC.SubseqResult.false = 1 | null | true |
Homotopy.compLeft | Mathlib.Algebra.Homology.Homotopy | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{c : ComplexShape ι} →
{C D E : HomologicalComplex V c} →
{f g : D ⟶ E} →
Homotopy f g →
(e : C ⟶ D) → Homotopy (CategoryTheory.Ca... | homotopy is closed under composition (on the left) | true |
Sym2.inf | Mathlib.Order.Sym2 | {α : Type u_1} → [SemilatticeInf α] → Sym2 α → α | The infimum of the two elements. | true |
Aesop.RuleTerm.const.elim | Aesop.RuleTac.RuleTerm | {motive : Aesop.RuleTerm → Sort u} →
(t : Aesop.RuleTerm) → t.ctorIdx = 0 → ((decl : Lean.Name) → motive (Aesop.RuleTerm.const decl)) → motive t | null | false |
Algebra.SubmersivePresentation.jacobianRelationsOfHasCoeffs._proof_1 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_2} {S : Type u_4} {ι : Type u_1} {σ : Type u_5} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ) (R₀ : Type u_3)
[inst_4 : CommRing R₀] [inst_5 : Algebra R₀ R] [inst_6 : Algebra R₀ S] [inst_7 : IsScalarTower R₀ R S]
[P.... | null | false |
Std.DHashMap.Internal.Raw₀.getKey?_insert_self | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], (↑m).WF → ∀ {k : α} {v : β k}, (m.insert k v).getKey? k = some k | null | true |
Lean.Elab.Attribute.stx | Lean.Elab.Attributes | Lean.Elab.Attribute → Lean.Syntax | null | true |
CategoryTheory.Functor.splitEpiEquiv._proof_6 | Mathlib.CategoryTheory.Functor.EpiMono | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y)
[inst_2 : F.Full] [inst_3 : F.Faithful] (x : CategoryTheory.SplitEpi (F.map f)),
(fun f_1 => f_1.map F) ((fun s => { section_ := F.pr... | null | false |
_private.Mathlib.MeasureTheory.Measure.Typeclasses.SFinite.0.MeasureTheory.Measure.countable_meas_pos_of_disjoint_iUnion₀._simp_1_4 | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (a ≤ 0) = (a = 0) | null | false |
_private.Init.TacticsExtra.0.Lean.Parser.Tactic._aux_Init_TacticsExtra___macroRules_Lean_Parser_Tactic_tacticRw_mod_cast____1.match_1 | Init.TacticsExtra | (motive : Option (Lean.TSyntax `Lean.Parser.Tactic.location) → Sort u_1) →
(loc : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) →
((loc : Lean.TSyntax `Lean.Parser.Tactic.location) → motive (some loc)) →
((x : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) → motive x) → motive loc | null | false |
Cardinal.add_one_inj | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {α β : Cardinal.{u_1}}, α + 1 = β + 1 ↔ α = β | null | true |
PowerSeries.IsWeierstrassDivision.unique | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | ∀ {A : Type u_1} [inst : CommRing A] [inst_1 : IsLocalRing A] {f g : PowerSeries A},
(PowerSeries.map (IsLocalRing.residue A)) g ≠ 0 →
∀ [inst_2 : IsAdicComplete (IsLocalRing.maximalIdeal A) A] {q : PowerSeries A} {r : Polynomial A},
f.IsWeierstrassDivision g q r → q = f /ʷ g ∧ r = f %ʷ g | If `q` and `r` are quotient and remainder in the Weierstrass division `f / g`, then they are
equal to `f /ʷ g` and `f %ʷ g`. | true |
Ideal.add_eq_sup | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : Semiring R] {I J : Ideal R}, I + J = I ⊔ J | null | true |
_private.Mathlib.LinearAlgebra.TensorProduct.Map.0.LinearMap.rTensor_neg._simp_1_1 | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_4) {N : Type u_5} {P : Type u_6} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P], LinearMap.rTensor M = ⇑(LinearMap.rTensorHom M) | null | false |
IsRightRegular.mul_right_eq_self_iff | Mathlib.Algebra.Regular.Basic | ∀ {R : Type u_1} [inst : Monoid R] {a b : R}, IsRightRegular a → (b * a = a ↔ b = 1) | null | true |
StrictAnti.strictAntiOn | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
StrictAnti f → ∀ (s : Set α), StrictAntiOn f s | null | true |
NonUnitalStarRingHom.copy._proof_2 | Mathlib.Algebra.Star.StarRingHom | ∀ {A : Type u_2} {B : Type u_1} [inst : NonUnitalNonAssocSemiring A] [inst_1 : Star A]
[inst_2 : NonUnitalNonAssocSemiring B] [inst_3 : Star B] (f : A →⋆ₙ+* B) (f' : A → B), f' = ⇑f → f' 0 = 0 | null | false |
Lean.Elab.FixedParams.instToFormatInfo | Lean.Elab.PreDefinition.FixedParams | Std.ToFormat Lean.Elab.FixedParams.Info | null | true |
BitVec.ushiftRight_eq_extractLsb'_of_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {n : ℕ} (hn : n < w), x >>> n = BitVec.cast ⋯ (0#n ++ BitVec.extractLsb' n (w - n) x) | null | true |
HomologicalComplex.leftUnitor'_inv_comm_assoc | Mathlib.Algebra.Homology.Monoidal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Limits.HasZeroObject C]
[inst_4 : (CategoryTheory.MonoidalCategory.curriedTensor C).Additive]
[inst_5 : ∀ (X₁ : C), ((CategoryTheory.Monoidal... | null | true |
FirstOrder.Field.FieldAxiom.toProp | Mathlib.ModelTheory.Algebra.Field.Basic | (K : Type u_2) → [Add K] → [Mul K] → [Neg K] → [Zero K] → [One K] → FirstOrder.Field.FieldAxiom → Prop | The Proposition corresponding to each field axiom | true |
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.PadicSeq.equiv_zero_of_val_eq_of_equiv_zero.match_1_1 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {f : PadicSeq p} (ε : ℚ)
(motive : (∃ i, ∀ j ≥ i, padicNorm p (↑(f - 0) j) < ε) → Prop) (x : ∃ i, ∀ j ≥ i, padicNorm p (↑(f - 0) j) < ε),
(∀ (i : ℕ) (hi : ∀ j ≥ i, padicNorm p (↑(f - 0) j) < ε), motive ⋯) → motive x | null | false |
ProbabilityTheory.Kernel.isProper_iff_inter_eq_indicator_mul | Mathlib.Probability.Kernel.Proper | ∀ {X : Type u_1} {𝓑 𝓧 : MeasurableSpace X} {π : ProbabilityTheory.Kernel X X},
𝓑 ≤ 𝓧 →
(π.IsProper ↔
∀ ⦃A : Set X⦄,
MeasurableSet A → ∀ ⦃B : Set X⦄, MeasurableSet B → ∀ (x : X), (π x) (A ∩ B) = B.indicator 1 x * (π x) A) | null | true |
Std.Net.instDecidableEqIPv6Addr.decEq | Std.Net.Addr | (x x_1 : Std.Net.IPv6Addr) → Decidable (x = x_1) | null | true |
Algebra.WeaklyEtale.instTensorProduct | Mathlib.RingTheory.Etale.Weakly | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {T : Type u_3}
[inst_3 : CommRing T] [inst_4 : Algebra R T] [Algebra.WeaklyEtale R S], Algebra.WeaklyEtale T (TensorProduct R T S) | [Stacks Tag 092H](https://stacks.math.columbia.edu/tag/092H) ((2)) | true |
IsCancelSMul.toIsLeftCancelSMul | Mathlib.Algebra.Group.Action.Defs | ∀ {G : Type u_9} {P : Type u_10} {inst : SMul G P} [self : IsCancelSMul G P], IsLeftCancelSMul G P | null | true |
_private.Mathlib.Algebra.Homology.SpectralObject.SpectralSequence.0.CategoryTheory.Abelian.SpectralObject.SpectralSequence.homologyIso._proof_1 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ (r r' : ℤ), r + 1 = r' → r ≤ r' | null | false |
«_aux_Init_Notation___macroRules_term_∘__1» | Init.Notation | Lean.Macro | null | false |
DFinsupp.comapDomain'.congr_simp | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} {κ : Type u_1} [inst : (i : ι) → Zero (β i)] (h : κ → ι) {h' h'_1 : ι → κ}
(e_h' : h' = h'_1) (hh' : Function.LeftInverse h' h) (f f_1 : Π₀ (i : ι), β i),
f = f_1 → DFinsupp.comapDomain' h hh' f = DFinsupp.comapDomain' h ⋯ f_1 | null | true |
CategoryTheory.Precoverage.SubsheafClosure.amalgamate | Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {K : CategoryTheory.Precoverage C}
{F : CategoryTheory.Functor Cᵒᵖ (Type w)} {𝒮 : (Z : C) → Set (F.obj (Opposite.op Z))} {Z : C}
{R : CategoryTheory.Presieve Z},
R ∈ K.coverings Z →
∀ {y : CategoryTheory.Presieve.FamilyOfElements F R},
y.Compatib... | Gluing of sections in the closure. | true |
VectorField.mlieBracketWithin_congr_set | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s t : Set M} {x : M} {V W : (x : M) → ... | null | true |
Representation.isTrivial_def | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) [ρ.IsTrivial] (g : G), ρ g = LinearMap.id | null | true |
Lean.Kernel.Environment.addDeclWithoutChecking | Lean.Environment | Lean.Kernel.Environment → Lean.Declaration → Except Lean.Kernel.Exception Lean.Kernel.Environment | Add declaration to kernel without type checking it.
**WARNING** This function is meant for temporarily working around kernel performance issues.
It compromises soundness because, for example, a buggy tactic may produce an invalid proof,
and the kernel will not catch it if the new option is set to true.
| true |
CategoryTheory.isNoetherianObject_iff_isEventuallyConstant | Mathlib.CategoryTheory.Subobject.NoetherianObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
CategoryTheory.IsNoetherianObject X ↔
∀ (F : CategoryTheory.Functor ℕ (CategoryTheory.MonoOver X)), CategoryTheory.IsFiltered.IsEventuallyConstant F | null | true |
MulAction.is_one_preprimitive_iff | Mathlib.GroupTheory.GroupAction.MultiplePrimitivity | ∀ (M : Type u_1) (α : Type u_2) [inst : Group M] [inst_1 : MulAction M α],
MulAction.IsMultiplyPreprimitive M α 1 ↔ MulAction.IsPreprimitive M α | An action is preprimitive iff it is `1`-preprimitive. | true |
CategoryTheory.Functor.leftKanExtensionIsoFiberwiseColimit._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_2} {D : Type u_6} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_6} D] (L : CategoryTheory.Functor C D) {H : Type u_5}
[inst_2 : CategoryTheory.Category.{u_4, u_5} H] (F : CategoryTheory.Functor C H) [L.HasPointwiseLeftKanExtension F]
(X : D),
CategoryTheor... | null | false |
AlternatingMap.toMultilinearMap_zero | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_7}, ↑0 = 0 | null | true |
_private.Mathlib.Data.Nat.Squarefree.0.Nat.minSqFacAux.match_1._arg_pusher | Mathlib.Data.Nat.Squarefree | ∀ (motive : ℕ → ℕ → Sort u_1) (α : Sort u✝) (β : α → Sort v✝) (f : (x : α) → β x) (rel : ℕ → ℕ → α → Prop) (x x_1 : ℕ)
(h_1 : (n k : ℕ) → ((y : α) → rel n k y → β y) → motive n k),
((match (motive := (x x_2 : ℕ) → ((y : α) → rel x x_2 y → β y) → motive x x_2) x, x_1 with
| n, k => fun x => h_1 n k x)
fu... | null | false |
CochainComplex.augmentTruncate_hom_f_succ | Mathlib.Algebra.Homology.Augment | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(C : CochainComplex V ℕ) (i : ℕ), C.augmentTruncate.hom.f (i + 1) = CategoryTheory.CategoryStruct.id (C.X (i + 1)) | null | true |
_private.Mathlib.Algebra.Lie.SemiDirect.0.LieAlgebra.SemiDirectSum.instLieRing._abel_1 | Mathlib.Algebra.Lie.SemiDirect | ∀ {R : Type u_2} [inst : CommRing R] {K : Type u_1} [inst_1 : LieRing K] [inst_2 : LieAlgebra R K] {L : Type u_3}
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ψ : L →ₗ⁅R⁆ LieDerivation R K K) (x x_1 x_2 : K ⋊⁅ψ⁆ L),
⁅x.left, x_2.left⁆ + ⁅x_1.left, x_2.left⁆ + ((ψ x.right) x_2.left + (ψ x_1.right) x_2.left) -
... | null | false |
ArzelaAscoli.compactSpace_of_isClosedEmbedding | Mathlib.Topology.UniformSpace.Ascoli | ∀ {ι : Type u_1} {X : Type u_2} {α : Type u_3} [inst : TopologicalSpace X] [inst_1 : UniformSpace α] {F : ι → X → α}
[inst_2 : TopologicalSpace ι] {𝔖 : Set (Set X)},
(∀ K ∈ 𝔖, IsCompact K) →
Topology.IsClosedEmbedding (⇑(UniformOnFun.ofFun 𝔖) ∘ F) →
(∀ K ∈ 𝔖, EquicontinuousOn F K) → (∀ K ∈ 𝔖, ∀ x ∈ K... | A version of the **Arzela-Ascoli theorem**.
Let `X, ι` be topological spaces, `𝔖` a covering of `X` by compact subsets, `α` a uniform space,
and `F : ι → (X → α)`. Assume that:
* `F`, viewed as a function `ι → (X →ᵤ[𝔖] α)`, is a closed embedding (in other words, `ι`
identifies to a closed subset of `X →ᵤ[𝔖] α` th... | true |
Lean.Level.quote | Lean.Level | Lean.Level → optParam ℕ 0 → optParam Bool true → (Lean.LMVarId → Option ℕ) → Lean.Syntax.Level | null | true |
Lean.Parser.Term.structInstField | Lean.Parser.Term.Basic | Lean.Parser.Parser | null | true |
ModuleCat.restrictScalarsId | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | (R : Type u₁) → [inst : Ring R] → ModuleCat.restrictScalars (RingHom.id R) ≅ CategoryTheory.Functor.id (ModuleCat R) | The restriction of scalars by the identity morphism identifies to the
identity functor. | true |
QuadraticModuleCat.toModuleCat_tensor | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | ∀ {R : Type u} [inst : CommRing R] [inst_1 : Invertible 2] (X Y : QuadraticModuleCat R),
(CategoryTheory.MonoidalCategoryStruct.tensorObj X Y).toModuleCat =
CategoryTheory.MonoidalCategoryStruct.tensorObj X.toModuleCat Y.toModuleCat | null | true |
CategoryTheory.AddMon.equivLaxMonoidalFunctorPUnit_counitIso_inv_app_hom | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(X : CategoryTheory.AddMon C),
(CategoryTheory.AddMon.equivLaxMonoidalFunctorPUnit.counitIso.inv.app X).hom = CategoryTheory.CategoryStruct.id X.X | null | true |
WithTop.mul_lt_mul | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : CommSemiring α] [inst_2 : PartialOrder α] [OrderBot α]
[inst_4 : CanonicallyOrderedAdd α] [PosMulStrictMono α] {a₁ a₂ b₁ b₂ : WithTop α},
a₁ < a₂ → b₁ < b₂ → a₁ * b₁ < a₂ * b₂ | null | true |
_private.Mathlib.Algebra.Order.Field.Basic.0.sub_self_div_two._proof_1_1 | Mathlib.Algebra.Order.Field.Basic | (1 + 1).AtLeastTwo | null | false |
SimpleGraph.Subgraph.comap_equiv_top | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {W : Type v} {G : SimpleGraph V} {H : SimpleGraph W} (f : G →g H), SimpleGraph.Subgraph.comap f ⊤ = ⊤ | null | true |
exteriorPower.presentation.Rels | Mathlib.LinearAlgebra.ExteriorPower.Basic | Type u → Type u_4 → Type u_5 → Type (max (max u u_4) u_5) | The index type for the relations in the standard presentation of `⋀[R]^n M`,
in the particular case `ι` is `Fin n`. | true |
String.Slice.Pattern.Model.IsValidRevSearchFrom.below | Init.Data.String.Lemmas.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
[inst : String.Slice.Pattern.Model.PatternModel pat] →
{s : String.Slice} →
{motive :
(a : s.Pos) →
(a_1 : List (String.Slice.Pattern.SearchStep s)) →
String.Slice.Pattern.Model.IsValidRevSearchFrom pat a a_1 → Prop} →
{a :... | null | true |
CategoryTheory.Pretriangulated.Triangle.rotate_mor₂ | Mathlib.CategoryTheory.Triangulated.Rotate | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (T : CategoryTheory.Pretriangulated.Triangle C), T.rotate.mor₂ = T.mor₃ | null | true |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Presentation.Expr.4196812879._hygCtx._hyg.1.recOn | ProofWidgets.Presentation.Expr | {motive : ProofWidgets.RpcEncodablePacket✝ → Sort u} →
(t : ProofWidgets.RpcEncodablePacket✝) → ((expr : Lean.Json) → motive { expr := expr }) → motive t | null | false |
ULift.algebra | Mathlib.Algebra.Algebra.Basic | {R : Type u_1} →
{A : Type u_2} → [inst : CommSemiring R] → [inst_1 : Semiring A] → [Algebra R A] → Algebra R (ULift.{u_4, u_2} A) | null | true |
SimpleGraph.instSymmFinsetIsUniform | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] {G : SimpleGraph α}
[inst_2 : DecidableRel G.Adj] {ε : 𝕜}, Std.Symm (G.IsUniform ε) | null | true |
AbstractMeasure.instAddCommGroup._proof_11 | Mathlib.NumberTheory.Padics.Measure.Basic | ∀ {X : Type u_1} {R : Type u_2} {E : Type u_3} [inst : TopologicalSpace X] [inst_1 : AddCommGroup E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : CommRing R] [inst_5 : TopologicalSpace R]
[inst_6 : IsTopologicalRing R] [inst_7 : Module R E],
autoParam (∀ (n : ℕ) (x : AbstractMeasure ... | null | false |
CategoryTheory.EquivalenceRelation.recOn | Mathlib.CategoryTheory.EquivalenceRelation | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{R X : C} →
{p₁ p₂ : R ⟶ X} →
{motive : CategoryTheory.EquivalenceRelation p₁ p₂ → Sort u} →
(t : CategoryTheory.EquivalenceRelation p₁ p₂) →
((toReflexiveRelation : CategoryTheory.ReflexiveRelation p₁ p₂) →
... | null | false |
CategoryTheory.Triangulated.Octahedron.mk.noConfusion | Mathlib.CategoryTheory.Triangulated.Triangulated | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} 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 : Ca... | null | false |
_private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_deriv_norm | Mathlib.NumberTheory.Padics.Hensel | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommSemiring R] [inst_2 : Algebra R ℤ_[p]]
{F : Polynomial R} {a : ℤ_[p]}
(hnorm : ‖(Polynomial.aeval a) F‖ < ‖(Polynomial.aeval a) (Polynomial.derivative F)‖ ^ 2) (n : ℕ),
‖(Polynomial.aeval (newton_seq_gen✝ hnorm n)) (Polynomial.derivative F)‖ =
... | null | true |
Std.DTreeMap.Const.getD_insertMany_list_of_contains_eq_false | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
[inst : BEq α] [Std.LawfulBEqCmp cmp] {l : List (α × β)} {k : α} {fallback : β},
(List.map Prod.fst l).contains k = false →
Std.DTreeMap.Const.getD (Std.DTreeMap.Const.insertMany t l) k fallback = Std.D... | null | true |
Equiv.coframe._proof_10 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : Order.Coframe β] (a b : α), e (e.symm (e a \ e b)) = e a \ e b | null | false |
CategoryTheory.Presieve.Arrows.Compatible.familyOfElements.congr_simp | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {B : C}
{I : Type u_1} {X : I → C} {π π_1 : (i : I) → X i ⟶ B} (e_π : π = π_1) {x x_1 : (i : I) → P.obj (Opposite.op (X i))}
(e_x : x = x_1) (hx : CategoryTheory.Presieve.Arrows.Compatible P π x) ⦃Y : C⦄ (f f_1 : Y... | null | true |
MeasureTheory.OuterMeasure.mkMetric' | Mathlib.MeasureTheory.Measure.Hausdorff | {X : Type u_2} → [EMetricSpace X] → (Set X → ENNReal) → MeasureTheory.OuterMeasure X | Given a function `m : Set X → ℝ≥0∞`, `mkMetric' m` is the supremum of `mkMetric'.pre m r`
over `r > 0`. Equivalently, it is the limit of `mkMetric'.pre m r` as `r` tends to zero from
the right. | true |
AdjoinRoot.instCommRing._proof_43 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] (f : Polynomial R) (a b : AdjoinRoot f), a * b = b * a | null | false |
BitVec.instTransOrd | Init.Data.Ord.BitVec | ∀ {n : ℕ}, Std.TransOrd (BitVec n) | null | true |
Fin.preimage_rev_Ioo | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (i j : Fin n), Fin.rev ⁻¹' Set.Ioo i j = Set.Ioo j.rev i.rev | null | true |
Lean.Compiler.LCNF.Simp.State.mk.sizeOf_spec | Lean.Compiler.LCNF.Simp.SimpM | ∀ (subst : Lean.Compiler.LCNF.FVarSubst Lean.Compiler.LCNF.Purity.pure) (used : Lean.Compiler.LCNF.UsedLocalDecls)
(binderRenaming : Lean.Compiler.LCNF.Renaming) (funDeclInfoMap : Lean.Compiler.LCNF.Simp.FunDeclInfoMap)
(simplified : Bool) (visited inline inlineLocal : ℕ),
sizeOf
{ subst := subst, used := u... | null | true |
Lean.Language.Lean.HeaderProcessedState.casesOn | Lean.Language.Lean.Types | {motive : Lean.Language.Lean.HeaderProcessedState → Sort u} →
(t : Lean.Language.Lean.HeaderProcessedState) →
((cmdState : Lean.Elab.Command.State) →
(firstCmdSnap : Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot) →
motive { cmdState := cmdState, firstCmdSnap := firstCmdSnap... | null | false |
Nat.map_add_toArray_roc | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n k : ℕ}, Array.map (fun x => x + k) (m<...=n).toArray = (m + k<...=n + k).toArray | null | true |
Lean.Grind.decide_eq_false | Init.Grind.Lemmas | ∀ {p : Prop} {x : Decidable p}, p = False → decide p = false | null | true |
CategoryTheory.Bicategory.Pith.pseudofunctorToPithCompInclusionStrongIsoHom._proof_6 | Mathlib.CategoryTheory.Bicategory.LocallyGroupoid | ∀ {B : Type u_6} [inst : CategoryTheory.Bicategory B] {B' : Type u_2} [inst_1 : CategoryTheory.Bicategory B']
[inst_2 : CategoryTheory.Bicategory.IsLocallyGroupoid B'] (F : CategoryTheory.Pseudofunctor B' B) {a b c : B'}
(f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.... | null | false |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithInitial.opEquiv.match_5.splitter | Mathlib.CategoryTheory.WithTerminal.Basic | (C : Type u_2) →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
{x y : (CategoryTheory.WithInitial C)ᵒᵖ} →
(motive : (x ⟶ y) → Sort u_3) →
(x_1 : x ⟶ y) → ((f : Opposite.unop y ⟶ Opposite.unop x) → motive (Opposite.op f)) → motive x_1 | null | true |
RBTree.RBNode.del.eq_def | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} (cut : α → Ordering) (x : RBTree.RBNode α),
RBTree.RBNode.del cut x =
match x with
| RBTree.RBNode.nil => RBTree.RBNode.nil
| RBTree.RBNode.node c a y b =>
match cut y with
| Ordering.lt =>
match a.isBlack with
| RBTree.RBColor.black => (RBTree.RBNode.del cut a... | null | true |
CategoryTheory.Functor.isRightAdjoint_comp | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {F : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D E} [F.IsRightAdjoint] [G.IsRightAdjoint], (F.comp G).IsRightAdjoint | If `F` and `G` are right adjoints then `F ⋙ G` is a right adjoint too. | true |
alternatingGroup.normal | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α], (alternatingGroup α).Normal | null | true |
SemimoduleCat.MonoidalCategory.associator | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | {R : Type u} →
[inst : CommSemiring R] →
(M : SemimoduleCat R) →
(N : SemimoduleCat R) →
(K : SemimoduleCat R) →
SemimoduleCat.MonoidalCategory.tensorObj (SemimoduleCat.MonoidalCategory.tensorObj M N) K ≅
SemimoduleCat.MonoidalCategory.tensorObj M (SemimoduleCat.MonoidalCategor... | (implementation) the associator for R-modules | true |
AddUnits.val_zero | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : AddMonoid α], ↑0 = 0 | null | true |
Std.TreeSet.foldr_eq_foldr_toArray | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} {δ : Type w} {f : α → δ → δ} {init : δ},
Std.TreeSet.foldr f init t = Array.foldr f init t.toArray | null | true |
StalkSkyscraperPresheafAdjunctionAuxs.fromStalk._proof_2 | Mathlib.Topology.Sheaves.Skyscraper | ∀ {X : TopCat} (p₀ : ↑X) [inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type u_1}
[inst_1 : CategoryTheory.Category.{u_2, u_1} C] [inst_2 : CategoryTheory.Limits.HasTerminal C] {c : C}
(U : (TopologicalSpace.OpenNhds p₀)ᵒᵖ), (if p₀ ∈ ↑(Opposite.unop U) then c else ⊤_ C) = c | null | false |
Stream'.Seq.Corec.f.match_1 | Mathlib.Data.Seq.Defs | {β : Type u_1} →
(motive : Option β → Sort u_2) → (x : Option β) → (Unit → motive none) → ((b : β) → motive (some b)) → motive x | null | false |
String.Pos.revSkip?_bool_eq_none_iff._simp_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {p : Char → Bool} {s : String} {pos : s.Pos},
(pos.revSkip? p = none) = ∀ (h : pos ≠ s.startPos), p ((pos.prev h).get ⋯) = false | null | false |
RCLike.re_eq_complex_re | Mathlib.Analysis.Complex.Basic | ⇑RCLike.re = Complex.re | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.