name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
neg_mul | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u} [inst : Mul α] [inst_1 : HasDistribNeg α] (a b : α), -a * b = -(a * b) | null | true |
TopCat.Sheaf.existsUnique_gluing | Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {FC : C → C → Type u_2} {CC : C → Type u_3}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC]
[CategoryTheory.Limits.HasLimitsOfSize.{x, x, v_1, u_1} C] [(CategoryTheory.forget C).ReflectsIsomorphisms]... | A more convenient way of obtaining a unique gluing of sections for a sheaf.
| true |
Std.Internal.List.getKey!_nil | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Inhabited α] {a : α}, Std.Internal.List.getKey! a [] = default | null | true |
_private.Std.Data.ExtDTreeMap.Lemmas.0.Std.ExtDTreeMap.Const.alter_eq_empty_iff_erase_eq_empty._simp_1_1 | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [Std.TransCmp cmp],
(t = ∅) = (t.isEmpty = true) | null | false |
CategoryTheory.Abelian.SpectralObject.p_fromOpcycles_assoc | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n : ... | null | true |
Con.comap_eq | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {c : Con M} {f : N →* M},
Con.comap ⇑f ⋯ c = Con.ker (c.mk'.comp f) | Given a monoid homomorphism `f : N → M` and a congruence relation `c` on `M`, the congruence
relation induced on `N` by `f` equals the kernel of `c`'s quotient homomorphism composed with
`f`. | true |
CategoryTheory.MonObj.ofIso._proof_2 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {M X : C}
[inst_2 : CategoryTheory.MonObj M] (e : M ≅ X),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.CategoryStruct.comp CategoryTheor... | null | false |
Std.TreeMap.Raw.getKey?_insertIfNew | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k a : α} {v : β}, (t.insertIfNew k v).getKey? a = if cmp k a = Ordering.eq ∧ k ∉ t then some k else t.getKey? a | null | true |
CategoryTheory.Limits.reflexiveCoforkEquivCofork_functor_obj_π | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Functor CategoryTheory.Limits.WalkingReflexivePair C)
(G : CategoryTheory.Limits.ReflexiveCofork F),
((CategoryTheory.Limits.reflexiveCoforkEquivCofork F).functor.obj G).π = G.π | null | true |
FractionalIdeal.mem_add | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
(I J : FractionalIdeal S P) (x : P), x ∈ I + J ↔ ∃ i ∈ I, ∃ j ∈ J, i + j = x | null | true |
HasSubset.Subset.eq_of_not_ssubset | Mathlib.Order.RelClasses | ∀ {α : Type u_2} [UsesSetNotationForOrder α] [inst : PartialOrder α] {a b : α}, a ⊆ b → ¬a ⊂ b → a = b | **Alias** of `LE.le.eq_of_not_ssubset`.
---
Set notation form of `LE.le.eq_of_not_lt` | true |
MeasureTheory.Measure.instPartialOrder._proof_1 | Mathlib.MeasureTheory.Measure.CompleteLattice | ∀ {α : Type u_1} {mα : MeasurableSpace α} (a b : MeasureTheory.Measure α),
(fun m₁ m₂ => ∀ (s : Set α), m₁ s ≤ m₂ s) a b ∧ ¬(fun m₁ m₂ => ∀ (s : Set α), m₁ s ≤ m₂ s) b a ↔
(∀ (s : Set α), a s ≤ b s) ∧ ¬∀ (s : Set α), b s ≤ a s | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks.0.SimpleGraph.Walk.isSubwalk_iff_darts_isInfix._proof_1_53 | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v u' v' : V} {p₁ : G.Walk u v} {p₂ : G.Walk u' v'} (k i : ℕ),
(∀ (h : i < p₁.darts.length), p₂.darts[i + k]? = some p₁.darts[i]) → i + 1 ≤ p₁.darts.length → k + i < p₂.darts.length | null | false |
Lean.Meta.Grind.GoalState.exprs | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.GoalState → Lean.PArray Lean.Expr | null | true |
MeasureTheory.LocallyIntegrable.congr | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f g : X → ε} {μ : MeasureTheory.Measure X},
MeasureTheory.LocallyIntegrable f μ → f =ᵐ[μ] g → MeasureTheory.LocallyIntegrable g μ | null | true |
IO.FS.Metadata.noConfusion | Init.System.IO | {P : Sort u} → {t t' : IO.FS.Metadata} → t = t' → IO.FS.Metadata.noConfusionType P t t' | null | false |
RingQuot.eqvGen_rel_eq | Mathlib.Algebra.RingQuot | ∀ {R : Type uR} [inst : Semiring R] (r : R → R → Prop), Relation.EqvGen (RingQuot.Rel r) = RingConGen.Rel r | null | true |
_private.Lean.Meta.Tactic.Simp.SimpCongrTheorems.0.Lean.Meta.SimpCongrTheorems.get.match_1 | Lean.Meta.Tactic.Simp.SimpCongrTheorems | (motive : Option (List Lean.Meta.SimpCongrTheorem) → Sort u_1) →
(x : Option (List Lean.Meta.SimpCongrTheorem)) →
(Unit → motive none) → ((cs : List Lean.Meta.SimpCongrTheorem) → motive (some cs)) → motive x | null | false |
_private.Lean.Language.Lean.Util.0.Lean.Language.SnapshotTree.findInfoTreeAtPos._sparseCasesOn_1 | Lean.Language.Lean.Util | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Manifold.IsImmersionAtOfComplement.of_opens | Mathlib.Geometry.Manifold.Immersion | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_7} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_11}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {n : WithTop ℕ∞} [IsManifold I n M]
... | null | true |
CategoryTheory.sheafification | Mathlib.CategoryTheory.Sites.Sheafification | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(D : Type u_1) →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
[CategoryTheory.HasWeakSheafify J D] →
CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ D) (CategoryT... | The sheafification of a presheaf `P`, as a functor. | true |
_private.Mathlib.MeasureTheory.VectorMeasure.BoundedVariation.0.BoundedVariationOn.variation_vectorMeasure_Ioi._proof_1_15 | Mathlib.MeasureTheory.VectorMeasure.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] {a : α} (n : ℕ) (u : ℕ → α),
Monotone u → (∀ (i : ℕ), a < u i) → ∀ (b : α), u n < b → ∀ i ≤ n, u i ∈ Set.Ioo a b | null | false |
Aesop.EMap.foldl | Aesop.EMap | {σ : Type} → {α : Type u_1} → σ → (σ → Lean.Expr → α → σ) → Aesop.EMap α → σ | null | true |
OrderedFinpartition.eraseLeft.eq_1 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition (n + 1)) (hc : Set.range (c.emb 0) = {0}),
c.eraseLeft hc =
{ length := c.length - 1,
partSize :=
have this := ⋯;
fun i => c.partSize (Fin.cast this i.succ),
partSize_pos := ⋯,
emb := fun i j =>
have this := ⋯;
(c.emb (Fin.cast t... | null | true |
ModuleCat.MonoidalCategory.tensor_ext | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | ∀ {R : Type u} [inst : CommRing R] {M₁ M₂ M₃ : ModuleCat R}
{f g : CategoryTheory.MonoidalCategoryStruct.tensorObj M₁ M₂ ⟶ M₃},
(∀ (m : ↑M₁) (n : ↑M₂), (ModuleCat.Hom.hom f) (m ⊗ₜ[R] n) = (ModuleCat.Hom.hom g) (m ⊗ₜ[R] n)) → f = g | null | true |
Path.refl_symm | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {a : X}, (Path.refl a).symm = Path.refl a | null | true |
Std.PRange.UpwardEnumerable.Map.PreservesLE.le_iff | Init.Data.Range.Polymorphic.Map | ∀ {α : Type u_1} {β : Type u_2} {inst : Std.PRange.UpwardEnumerable α} {inst_1 : Std.PRange.UpwardEnumerable β}
{inst_2 : LE α} {inst_3 : LE β} {f : Std.PRange.UpwardEnumerable.Map α β} [self : f.PreservesLE] {a b : α},
a ≤ b ↔ f.toFun a ≤ f.toFun b | null | true |
Equiv.Perm.isCycle_swap_mul_aux₂ | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_4} [inst : DecidableEq α] (n : ℤ) {b x : α} {f : Equiv.Perm α},
(Equiv.swap x (f x) * f) b ≠ b → (f ^ n) (f x) = b → ∃ i, ((Equiv.swap x (f x) * f) ^ i) (f x) = b | null | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.visitConst._sparseCasesOn_1 | Lean.Meta.LetToHave | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
IsSelfNeg.one._simp_1 | Mathlib.Algebra.CharP.Two | ∀ {R : Type u_1} [inst : AddGroupWithOne R] [CharP R 2], IsSelfNeg 1 = True | null | false |
Not.decidable_imp_symm | Mathlib.Basic.Logic.Basic | ∀ {a b : Prop} [Decidable a], (¬a → b) → ¬b → a | **Alias** of `Decidable.not_imp_symm`. | true |
Mathlib.Tactic.Order.AtomicFact.eq.injEq | Mathlib.Tactic.Order.CollectFacts | ∀ (lhs rhs : ℕ) (proof : Lean.Expr) (lhs_1 rhs_1 : ℕ) (proof_1 : Lean.Expr),
(Mathlib.Tactic.Order.AtomicFact.eq lhs rhs proof = Mathlib.Tactic.Order.AtomicFact.eq lhs_1 rhs_1 proof_1) =
(lhs = lhs_1 ∧ rhs = rhs_1 ∧ proof = proof_1) | null | true |
CategoryTheory.Pretriangulated.TriangleMorphism.mk.congr_simp | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
{T₁ T₂ : CategoryTheory.Pretriangulated.Triangle C} (hom₁ hom₁_1 : T₁.obj₁ ⟶ T₂.obj₁) (e_hom₁ : hom₁ = hom₁_1)
(hom₂ hom₂_1 : T₁.obj₂ ⟶ T₂.obj₂) (e_hom₂ : hom₂ = hom₂_1) (hom₃ hom₃_1 : T₁.obj₃ ⟶ T₂.obj₃) (e_hom₃ : hom₃ =... | null | true |
IsRelPrime.mul_add_right_right | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommRing R] {x y : R}, IsRelPrime x y → ∀ (z : R), IsRelPrime x (z * x + y) | null | true |
Ideal.Quotient.groupWithZero._proof_12 | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {R : Type u_1} [inst : Ring R] (I : Ideal R) [inst_1 : I.IsTwoSided] [hI : I.IsMaximal] (a : R ⧸ I),
a ≠ 0 → a * a⁻¹ = 1 | null | false |
DenseRange.eq_zero_of_inner_left | Mathlib.Analysis.InnerProductSpace.Continuous | ∀ {E : Type u_3} {ι : Type u_4} (𝕜 : Type u_5) [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] {x : E} {f : ι → E}, DenseRange f → (∀ (i : ι), inner 𝕜 x (f i) = 0) → x = 0 | null | true |
_private.Init.Data.Array.QSort.Basic.0.Array.qsort._auto_6 | Init.Data.Array.QSort.Basic | Lean.Syntax | null | false |
_private.Lean.Meta.Tactic.Simp.SimpAll.0.Lean.Meta.SimpAll.main.match_1 | Lean.Meta.Tactic.Simp.SimpAll | (motive : Array Lean.FVarId × Lean.MVarId → Sort u_1) →
(x : Array Lean.FVarId × Lean.MVarId) →
((fst : Array Lean.FVarId) → (mvarId : Lean.MVarId) → motive (fst, mvarId)) → motive x | null | false |
Computation.thinkN._sunfold | Mathlib.Data.Seq.Computation | {α : Type u} → Computation α → ℕ → Computation α | null | false |
Std.HashSet.get_diff | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{k : α} {h_mem : k ∈ m₁ \ m₂}, (m₁ \ m₂).get k h_mem = m₁.get k ⋯ | null | true |
Finsupp.instMetricSpaceWithLpOfNNReal._proof_2 | Mathlib.Analysis.Normed.Lp.Finsupp | ∀ {ι : Type u_1} {X : Type u_2} [inst : Zero X] {p : NNReal} [inst_1 : Fact (1 ≤ p)] [inst_2 : MetricSpace X]
(f g : WithLp (↑p) (ι →₀ X)),
edist f g = ENNReal.ofReal (((Finsupp.zipWith dist ⋯ f.ofLp g.ofLp).sum fun i r => r ^ ↑p) ^ (↑p)⁻¹) | null | false |
EReal.sub_lt_of_lt_add | Mathlib.Data.EReal.Operations | ∀ {a b c : EReal}, a < b + c → a - c < b | null | true |
Mathlib.Tactic.etaStruct? | Mathlib.Tactic.DefEqTransformations | Lean.Expr → optParam Bool true → Lean.MetaM (Option Lean.Expr) | Checks if the expression is of the form `S.mk x.1 ... x.n` with `n` nonzero
and `S.mk` a structure constructor and returns `x`.
Each projection `x.i` can be either a native projection or from a projection function.
`tryWhnfR` controls whether to try applying `whnfR` to arguments when none of them
are obviously project... | true |
MulArchimedean.of_locallyFiniteOrder | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_2} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] [LocallyFiniteOrder G],
MulArchimedean G | Any locally finite linear group is mul-archimedean. | true |
PythagoreanTriple.isPrimitiveClassified_of_coprime | Mathlib.NumberTheory.PythagoreanTriples | ∀ {x y z : ℤ} (h : PythagoreanTriple x y z), x.gcd y = 1 → h.IsPrimitiveClassified | null | true |
PrimeSpectrum.ConstructibleSetData.map_id | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | ∀ {R : Type u_1} [inst : CommSemiring R] (s : PrimeSpectrum.ConstructibleSetData R),
PrimeSpectrum.ConstructibleSetData.map (RingHom.id R) s = s | null | true |
LinearMap.linearEquivOfInjective.congr_simp | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {V₂ : Type v'}
[inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] [inst_5 : FiniteDimensional K V] [inst_6 : FiniteDimensional K V₂]
(f f_1 : V →ₗ[K] V₂) (e_f : f = f_1) (hf : Function.Injective ⇑f) (hdim : Module.fin... | null | true |
instInhabitedAddMonoidHom.eq_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : AddZero M] [inst_1 : AddZeroClass N],
instInhabitedAddMonoidHom = { default := 0 } | null | true |
Matrix.IsSelfAdjoint.eq_1 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {n : Type u_11} [inst : CommRing R] [inst_1 : Fintype n] (J A₁ : Matrix n n R),
J.IsSelfAdjoint A₁ = J.IsAdjointPair J A₁ A₁ | null | true |
Subrepresentation.mk.injEq | Mathlib.RepresentationTheory.Subrepresentation | ∀ {A : Type u_1} {G : Type u_2} {W : Type u_3} [inst : Semiring A] [inst_1 : Monoid G] [inst_2 : AddCommMonoid W]
[inst_3 : Module A W] {ρ : Representation A G W} (toSubmodule : Submodule A W)
(apply_mem_toSubmodule : ∀ (g : G) ⦃v : W⦄, v ∈ toSubmodule → (ρ g) v ∈ toSubmodule) (toSubmodule_1 : Submodule A W)
(app... | null | true |
MeasureTheory.laverage_lt_top | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
∫⁻ (x : α), f x ∂μ ≠ ⊤ → ⨍⁻ (x : α), f x ∂μ < ⊤ | null | true |
_private.ImportGraph.Shake.Workspace.0.ImportGraph.Shake.DeclNeeds.toSimultaneousImportNeeds._sparseCasesOn_1 | ImportGraph.Shake.Workspace | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Algebra.CharP.Basic.0.Int.cast_injOn_of_ringChar_ne_two._simp_1_3 | Mathlib.Algebra.CharP.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (0 = 1) = False | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.optDeclSig.formatter_49 | Lean.Parser.Command | IO Unit | null | false |
List.append_of_mem | Init.Data.List.Lemmas | ∀ {α : Type u_1} {a : α} {l : List α}, a ∈ l → ∃ s t, l = s ++ a :: t | See also `eq_append_cons_of_mem`, which proves a stronger version
in which the initial list must not contain the element.
| true |
CliffordAlgebra.involute | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | {R : Type u_1} →
[inst : CommRing R] →
{M : Type u_2} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → {Q : QuadraticForm R M} → CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q | Grade involution, inverting the sign of each basis vector. | true |
_private.Mathlib.Tactic.Inclusion.Extension.IntervalDyadicReal.Rational.0.Inclusion.IntervalDyadicReal.scientific_mem._simp_1_2 | Mathlib.Tactic.Inclusion.Extension.IntervalDyadicReal.Rational | ∀ {x : ℝ} {I : Inclusion.Interval Dyadic}, (x ∈ I) = (x ∈ I.map Dyadic.toReal) | null | false |
add_zsmul_add | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : AddGroup G] (a b : G) (n : ℤ), n • (a + b) + a = a + n • (b + a) | null | true |
MeasureTheory.Content.recOn | Mathlib.MeasureTheory.Measure.Content | {G : Type w} →
[inst : TopologicalSpace G] →
{motive : MeasureTheory.Content G → Sort u} →
(t : MeasureTheory.Content G) →
((toFun : TopologicalSpace.Compacts G → NNReal) →
(mono' : ∀ (K₁ K₂ : TopologicalSpace.Compacts G), ↑K₁ ⊆ ↑K₂ → toFun K₁ ≤ toFun K₂) →
(sup_disjoint' :... | null | false |
CategoryTheory.ShortComplex.HomologyMapData.mk.inj | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.Limits.HasZeroMorphisms C}
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {h₁ : S₁.HomologyData} {h₂ : S₂.HomologyData}
{left : CategoryTheory.ShortComplex.LeftHomologyMapData φ h₁.left h₂.left}
{right : CategoryTheory.ShortC... | null | true |
Stream'.get_tail | Mathlib.Data.Stream.Init | ∀ {α : Type u} {n : ℕ} {s : Stream' α}, s.tail.get n = s.get (n + 1) | null | true |
Turing.TM2ComputableInTime.rec | Mathlib.Computability.TuringMachine.Computable | {α β αΓ βΓ : Type} →
{ea : α → List αΓ} →
{eb : β → List βΓ} →
{f : α → β} →
{motive : Turing.TM2ComputableInTime ea eb f → Sort u} →
((toTM2ComputableAux : Turing.TM2ComputableAux αΓ βΓ) →
(time : ℕ → ℕ) →
(outputsFun :
(a : α) →
... | null | false |
_private.Lean.Meta.Transform.0.Lean.Meta.transformWithCache.visit.visitLambda._unsafe_rec | Lean.Meta.Transform | {m : Type → Type} →
[Monad m] →
[MonadLiftT Lean.MetaM m] →
[MonadControlT Lean.MetaM m] →
(Lean.Expr → m Lean.TransformStep) →
(Lean.Expr → m Lean.TransformStep) →
Bool →
Bool →
Bool →
(x : STWorld IO.RealWorld m) →
... | null | false |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.SelectM.State.suggestions | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Meta.Grind.SelectM.State✝ → Array Lean.Meta.Tactic.TryThis.Suggestion | null | true |
CategoryTheory.pi.coneOfConeEvalIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.Pi | ∀ {I : Type u_1} {C : I → Type u_2} [inst : (i : I) → CategoryTheory.Category.{u_1, u_2} (C i)] {J : Type u_1}
[inst_1 : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J ((i : I) → C i)}
{c : (i : I) → CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Pi.eval C i))}
(P : (i : I) → CategoryTheory.Lim... | null | false |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution'.b | Mathlib.NumberTheory.FLT.Three | {K : Type u_1} →
[inst : Field K] →
{ζ : K} → {hζ : IsPrimitiveRoot ζ 3} → FermatLastTheoremForThreeGen.Solution'✝ hζ → NumberField.RingOfIntegers K | null | true |
Submodule.equivOpposite._proof_2 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Semiring A] [inst_2 : Algebra R A]
(p q : Submodule R Aᵐᵒᵖ),
MulOpposite.op (Submodule.comap (↑(MulOpposite.opLinearEquiv R)) (p + q)) =
MulOpposite.op (Submodule.comap (↑(MulOpposite.opLinearEquiv R)) p) +
MulOpposite.op (Submodule.comap (... | null | false |
Equiv.booleanAlgebra._proof_4 | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : BooleanAlgebra β] (a b : α), e (e.symm (e a ⊓ e b)) = e a ⊓ e b | null | false |
_private.Mathlib.CategoryTheory.Sites.Descent.Precoverage.0.CategoryTheory.Pseudofunctor.DescentData.full_pullFunctor.sieve.fac | Mathlib.CategoryTheory.Sites.Descent.Precoverage | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type t} {S : C} {X : ι → C} {f : (i : ι) → X i ⟶ S}
{ι' : Type t'} {X' : ι' → C} {f' : (j : ι') → X' j ⟶ S} {i : ι} {Z : C} {q : Z ⟶ X i}
(hq :
(CategoryTheory.Pseudofunctor.DescentData.full_pullFunctor.sieve✝ f f' i).arrows (CategoryTheory.Over.homM... | null | true |
CategoryTheory.Limits.Cofork.ofCocone.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C} (t : CategoryTheory.Limits.Cocone F),
CategoryTheory.Limits.Cofork.ofCocone t =
{ pt := t.pt,
ι :=
{ app := fun X => CategoryTheory.CategoryStruct.comp (CategoryTheory.... | null | true |
Set.singleton_zero | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Zero α], {0} = 0 | null | true |
String.Internal.nextWhile | Init.Data.String.Bootstrap | String → (Char → Bool) → String.Pos.Raw → String.Pos.Raw | null | true |
QuotientAddGroup.automorphize_smul_left | Mathlib.Topology.Algebra.InfiniteSum.Module | ∀ {M : Type u_10} [inst : TopologicalSpace M] [inst_1 : AddCommMonoid M] [T2Space M] {R : Type u_11}
[inst_3 : DivisionRing R] [inst_4 : Module R M] [ContinuousConstSMul R M] {G : Type u_12} [inst_6 : AddGroup G]
{Γ : AddSubgroup G} (f : G → M) (g : G ⧸ Γ → R),
QuotientAddGroup.automorphize (g ∘ Quotient.mk' • f)... | Automorphization of a function into an `R`-`Module` distributes, that is, commutes with the
`R`-scalar multiplication. | true |
isLocalHom_id | Mathlib.RingTheory.LocalRing.RingHom.Basic | ∀ (R : Type u_4) [inst : Semiring R], IsLocalHom (RingHom.id R) | null | true |
Std.Http.Config.maxStartLineLength | Std.Http.Server.Config | Std.Http.Config → ℕ | Maximum number of bytes consumed while parsing request start-lines (default: 8192 bytes).
| true |
AlgebraicGeometry.Scheme.Hom.copyBase.eq_1 | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) (g : ↥X → ↥Y) (h : ⇑f = g),
f.copyBase g h =
{ base := TopCat.ofHom { toFun := g, continuous_toFun := ⋯ },
c := CategoryTheory.CategoryStruct.comp f.c (TopCat.Presheaf.pushforwardEq ⋯ X.presheaf).hom, prop := ⋯ } | null | true |
CategoryTheory.FreeMonoidalCategory.HomEquiv.id_tensorHom_id | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u} {X Y : CategoryTheory.FreeMonoidalCategory C},
CategoryTheory.FreeMonoidalCategory.HomEquiv
((CategoryTheory.FreeMonoidalCategory.Hom.id X).tensor (CategoryTheory.FreeMonoidalCategory.Hom.id Y))
(CategoryTheory.FreeMonoidalCategory.Hom.id (X.tensor Y)) | null | true |
CategoryTheory.Functor.uncurry._proof_5 | Mathlib.CategoryTheory.Functor.Currying | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_1, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_6, u_2} D] {E : Type u_5} [inst_2 : CategoryTheory.Category.{u_3, u_5} E]
(X : CategoryTheory.Functor C (CategoryTheory.Functor D E)),
{ app := fun X_1 => ((CategoryTheory.CategoryStruct.id X).app X_... | null | false |
QuadraticMap.noConfusionType | Mathlib.LinearAlgebra.QuadraticForm.Basic | Sort u_1 →
{R : Type u} →
{M : Type v} →
{N : Type w} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R N] →
QuadraticMap R M N →
{... | null | false |
_private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.evalNatCast.match_31 | Mathlib.Tactic.Positivity.Basic | (a : Q(ℕ)) →
(zα' : Q(Zero ℕ)) →
(pα' : Q(PartialOrder ℕ)) →
(motive : Mathlib.Meta.Positivity.Strictness zα' a (some pα') → Sort u_1) →
(__do_lift : Mathlib.Meta.Positivity.Strictness zα' a (some pα')) →
((pa : Q(0 < «$a»)) → motive (Mathlib.Meta.Positivity.Strictness.positive pa)) →
... | null | false |
_private.Mathlib.Data.List.Lattice.0.List.bagInter_erase_of_notMem._proof_1_1 | Mathlib.Data.List.Lattice | ∀ {α : Type u_1} {a : α} [inst : DecidableEq α] {l₂ : List α}, [].bagInter (l₂.erase a) = [].bagInter l₂ | null | false |
unitInterval.instIsProbabilityMeasureElemRealVolume | Mathlib.MeasureTheory.Constructions.UnitInterval | MeasureTheory.IsProbabilityMeasure MeasureTheory.volume | null | true |
lt_of_lt_mul_of_le_one_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b c : α} [inst : MulOneClass α] [inst_1 : Preorder α] [MulRightMono α], a < b * c → b ≤ 1 → a < c | null | true |
Geometry.SimplicialComplex.recOn | Mathlib.Analysis.Convex.SimplicialComplex.Basic | {𝕜 : Type u_1} →
{E : Type u_2} →
[inst : Ring 𝕜] →
[inst_1 : PartialOrder 𝕜] →
[inst_2 : AddCommGroup E] →
[inst_3 : Module 𝕜 E] →
{motive : Geometry.SimplicialComplex 𝕜 E → Sort u} →
(t : Geometry.SimplicialComplex 𝕜 E) →
((toPreAbstractSim... | null | false |
PresheafOfModules.pushforwardCompCoyonedaFreeYonedaCorepresentableBy._proof_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Pullback | ∀ {C D : Type u_1} [inst : CategoryTheory.SmallCategory C] [inst_1 : CategoryTheory.SmallCategory D]
{F : CategoryTheory.Functor C D} {R : CategoryTheory.Functor Dᵒᵖ RingCat} {S : CategoryTheory.Functor Cᵒᵖ RingCat}
(φ : S ⟶ F.op.comp R) (X : C) {M N : PresheafOfModules R} (g : M ⟶ N)
(f : (PresheafOfModules.free... | null | false |
IsAntichain.image_relIso | Mathlib.Order.Antichain | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {r' : β → β → Prop} {s : Set α},
IsAntichain r s → ∀ (φ : r ≃r r'), IsAntichain r' (⇑φ '' s) | null | true |
_private.Init.Data.UInt.Bitwise.0.USize.toUInt32_shiftLeft._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : USize}, (a < b) = (a.toNat < b.toNat) | null | false |
_private.Mathlib.Topology.Homotopy.Contractible.0.homotopic_of_indiscrete.match_1_1 | Mathlib.Topology.Homotopy.Contractible | {X : Type u_1} →
(motive : ↑unitInterval × X → Sort u_2) →
(x : ↑unitInterval × X) → ((t : ↑unitInterval) → (a : X) → motive (t, a)) → motive x | null | false |
_private.Lean.Elab.Tactic.Omega.OmegaM.0.Lean.Elab.Tactic.Omega.analyzeAtom.match_6 | Lean.Elab.Tactic.Omega.OmegaM | (motive : Lean.Name × Array Lean.Expr → Sort u_1) →
(x : Lean.Name × Array Lean.Expr) →
((head x' : Lean.Expr) → motive (`Nat.cast, #[Lean.Expr.const `Int [], head, x'])) →
((x : Lean.Name × Array Lean.Expr) → motive x) → motive x | null | false |
CategoryTheory.Functor.Fiber.fiberInclusion | Mathlib.CategoryTheory.FiberedCategory.Fiber | {𝒮 : Type u₁} →
{𝒳 : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳] →
{p : CategoryTheory.Functor 𝒳 𝒮} → {S : 𝒮} → CategoryTheory.Functor (p.Fiber S) 𝒳 | The functor including `Fiber p S` into `𝒳`. | true |
_private.Mathlib.Algebra.Algebra.Subalgebra.Lattice.0.Algebra.adjoin_union_coe_submodule._simp_1_1 | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {N : Type u_4} [inst : CommMonoid N] {s t : Submonoid N} {x : N}, (x ∈ s ⊔ t) = ∃ y ∈ s, ∃ z ∈ t, y * z = x | null | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.Pattern.isInstance | Lean.Meta.Sym.Pattern | Lean.Meta.Sym.Pattern → ℕ → Bool | Returns `true` if the `i`th argument / pattern variable is an instance. | true |
Fin.foldl.loop._unary | Init.Data.Fin.Fold | {α : Sort u_1} → (n : ℕ) → (α → Fin n → α) → (_ : α) ×' ℕ → α | Inner loop for `Fin.foldl`. `Fin.foldl.loop n f x i = f (f (f x i) ...) (n-1)`. | false |
Std.Time.Format.mk._flat_ctor | Std.Time.Format.Basic | {f : Type} →
{typ : Type → f → Type} →
((fmt : f) → typ String fmt) →
({α : Type} → (fmt : f) → typ (Option α) fmt → String → Except String α) → Std.Time.Format f typ | null | false |
Mathlib.Tactic.Translate.TranslationInfo.mk.noConfusion | Mathlib.Tactic.Translate.Expr | {P : Sort u} →
{translation : Lean.Name} →
{reorder : Mathlib.Tactic.Translate.Reorder} →
{relevantArg : Mathlib.Tactic.Translate.RelevantArg} →
{unfold : Bool} →
{translation' : Lean.Name} →
{reorder' : Mathlib.Tactic.Translate.Reorder} →
{relevantArg' : Mathlib.... | null | false |
MeasureTheory.VectorMeasure.setIntegral_compl | Mathlib.MeasureTheory.VectorMeasure.SetIntegral | ∀ {X : Type u_2} {E : Type u_3} {F : Type u_4} {G : Type u_5} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedAddCommGroup G] {μ : MeasureTheory.VectorMeasure X F} {f : X → E}
{s : Set X} [inst_3 : NormedSpace ℝ E] [inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpa... | null | true |
Finset.add_sum_Ioo_eq_sum_Ico | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] {f : α → M} {a b : α} [inst_1 : PartialOrder α]
[inst_2 : LocallyFiniteOrder α], a < b → f a + ∑ x ∈ Finset.Ioo a b, f x = ∑ x ∈ Finset.Ico a b, f x | null | true |
Std.DHashMap.Raw.Const.mem_alter_of_beq_eq_false | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [LawfulHashable α] {k k' : α} {f : Option β → Option β},
m.WF → (k == k') = false → (k' ∈ Std.DHashMap.Raw.Const.alter m k f ↔ k' ∈ m) | null | true |
Mathlib.Tactic.BicategoryLike.StructuralAtom.leftUnitor | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Lean.Expr → Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.StructuralAtom | The expression for the left unitor `λ_ f`. | true |
Lean.Meta.KExprMap.recOn | Lean.Meta.KExprMap | {α : Type} →
{motive : Lean.Meta.KExprMap α → Sort u} →
(t : Lean.Meta.KExprMap α) →
((map : Lean.PHashMap Lean.HeadIndex (Lean.AssocList Lean.Expr α)) → motive { map := map }) → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.