name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Submodule.mulRightMap.eq_1 | Mathlib.LinearAlgebra.Finsupp.LSum | ∀ {R : Type u_1} [inst : Semiring R] {S : Type u_4} [inst_1 : Semiring S] [inst_2 : Module R S]
[inst_3 : SMulCommClass R R S] [inst_4 : IsScalarTower R S S] (M : Submodule R S) {N : Submodule R S} {ι : Type u_5}
(n : ι → ↥N), M.mulRightMap n = (Finsupp.lsum R) fun i => MulOpposite.op ↑(n i) • M.subtype | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.initFn._@.Lean.Elab.DocString.202337124._hygCtx._hyg.2 | Lean.Elab.DocString | IO Unit | null | false |
CategoryTheory.nerve.ext_of_isThin | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [Quiver.IsThin C] {n : SimplexCategoryᵒᵖ}
{x y : (CategoryTheory.nerve C).obj n}, x.obj = y.obj → x = y | null | true |
HomologicalComplex.singleObjCyclesSelfIso_hom | Mathlib.Algebra.Homology.SingleHomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {ι : Type u_1} [inst_3 : DecidableEq ι] (c : ComplexShape ι) (j : ι)
(A : C),
(HomologicalComplex.singleObjCyclesSelfIso c j A).hom =
CategoryTheory.Cat... | null | true |
_private.Mathlib.LinearAlgebra.FreeModule.Int.0.Int.addSubgroup_index_ne_zero_iff.match_1_3 | Mathlib.LinearAlgebra.FreeModule.Int | ∀ {ι : Type u_1} {H : AddSubgroup (ι → ℤ)} (motive : Nonempty (↥(AddSubgroup.toIntSubmodule H) ≃ₗ[ℤ] ι → ℤ) → Prop)
(x : Nonempty (↥(AddSubgroup.toIntSubmodule H) ≃ₗ[ℤ] ι → ℤ)),
(∀ (e : ↥(AddSubgroup.toIntSubmodule H) ≃ₗ[ℤ] ι → ℤ), motive ⋯) → motive x | null | false |
MeasureTheory.quasiMeasurePreserving_add_left | Mathlib.MeasureTheory.Group.Prod | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd₂ G] (μ : MeasureTheory.Measure G)
[MeasureTheory.SFinite μ] [MeasurableNeg G] [μ.IsAddRightInvariant] (g : G),
MeasureTheory.QuasiMeasurePreserving (fun h => g + h) μ μ | A *right*-invariant measure is quasi-preserved by *left*-addition.
This should not be confused with `(measurePreserving_add_left μ g).quasiMeasurePreserving`. | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.eoi._regBuiltin.Lean.Parser.Command.eoi.formatter_3 | Lean.Parser.Command | IO Unit | null | false |
Setoid.quotientEquivClasses_mk_eq | Mathlib.Order.Setoid.Partition | ∀ {α : Type u_1} (r : Setoid α) (a : α), ↑(r.quotientEquivClasses ⟦a⟧) = {x | r x a} | null | true |
AlgebraicGeometry.IsPreimmersion.casesOn | Mathlib.AlgebraicGeometry.Morphisms.Preimmersion | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.IsPreimmersion f → Sort u} →
(t : AlgebraicGeometry.IsPreimmersion f) →
([toSurjectiveOnStalks : AlgebraicGeometry.SurjectiveOnStalks f] →
(isEmbedding : Topology.IsEmbedding ⇑f) → motive ⋯) →
motive t | null | false |
Subgroup.coe_sInf._simp_2 | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : Group G] (H : Set (Subgroup G)), ⋂ s ∈ H, ↑s = ↑(sInf H) | null | false |
MeasurableSet.ite | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} {m : MeasurableSpace α} {t s₁ s₂ : Set α},
MeasurableSet t → MeasurableSet s₁ → MeasurableSet s₂ → MeasurableSet (t.ite s₁ s₂) | null | true |
MeasurableEquiv.neg._proof_4 | Mathlib.MeasureTheory.Group.MeasurableEquiv | ∀ (G : Type u_1) [inst : MeasurableSpace G] [inst_1 : InvolutiveNeg G] [MeasurableNeg G],
Measurable ⇑(Equiv.symm (Equiv.neg G)) | null | false |
_private.Lean.Meta.Sym.Eta.0.Lean.Meta.Sym.etaReduce.go._f | Lean.Meta.Sym.Eta | Lean.Expr → (body : Lean.Expr) → Lean.Expr.below (motive := fun body => ℕ → Lean.Expr) body → ℕ → Lean.Expr | null | false |
LinearOrderedCommGroup.zpowersOrderMonoidIso._proof_2 | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_1} [inst : CommGroup G] (x : G), x = 1 → 1 ∈ Subgroup.zpowers x | null | false |
UInt8.complement | Init.Data.UInt.Basic | UInt8 → UInt8 | Bitwise complement, also known as bitwise negation, for 8-bit unsigned integers. Usually accessed
via the `~~~` prefix operator.
Each bit of the resulting integer is the opposite of the corresponding bit of the input integer.
This function is overridden at runtime with an efficient implementation.
| true |
CategoryTheory.Pretriangulated.Opposite.commShiftFunctorOpInt._proof_5 | Mathlib.CategoryTheory.Triangulated.Opposite.Functor | ∀ {C : Type u_1} {D : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] (F : CategoryTheory.Functor C D) [inst_4 : F.CommShift ℤ],
autoParam
(CategoryTheory.Pretriangulated.Oppos... | null | false |
Matroid.isCircuit_antichain | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {M : Matroid α}, IsAntichain (fun x1 x2 => x1 ⊆ x2) (Set.ofPred M.IsCircuit) | null | true |
HasStrictDerivAt.eventually_right_inverse | Mathlib.Analysis.Calculus.InverseFunctionTheorem.Deriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : CompleteSpace 𝕜] {f : 𝕜 → 𝕜} {f' a : 𝕜}
(hf : HasStrictDerivAt f f' a) (hf' : f' ≠ 0),
∀ᶠ (x : 𝕜) in nhds (f a), f (HasStrictDerivAt.localInverse f f' a hf hf' x) = x | null | true |
Primrec.vector_get' | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} [inst : Primcodable α] {n : ℕ}, Primrec List.Vector.get | null | true |
_private.Mathlib.Probability.Process.HittingTime.0.MeasureTheory.hittingAfter_mem_set_of_ne_top._simp_1_3 | Mathlib.Probability.Process.HittingTime | ∀ {a : Prop}, (¬¬a) = a | null | false |
Lean.Compiler.LCNF.PullFunDecls.ToPull.rec | Lean.Compiler.LCNF.PullFunDecls | {motive : Lean.Compiler.LCNF.PullFunDecls.ToPull → Sort u} →
((isFun : Bool) →
(decl : Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure) →
(used : Lean.FVarIdHashSet) → motive { isFun := isFun, decl := decl, used := used }) →
(t : Lean.Compiler.LCNF.PullFunDecls.ToPull) → motive t | null | false |
RootPairing.Equiv.ext_iff | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} {inst : CommRing R} {inst_1 : AddCommGroup M}
{inst_2 : Module R M} {inst_3 : AddCommGroup N} {inst_4 : Module R N} {ι₂ : Type u_5} {M₂ : Type u_6} {N₂ : Type u_7}
{inst_5 : AddCommGroup M₂} {inst_6 : Module R M₂} {inst_7 : AddCommGroup N₂} {inst_8 : Mod... | null | true |
List.length_of_sublistsLen | Mathlib.Data.List.Sublists | ∀ {α : Type u} {n : ℕ} {l l' : List α}, l' ∈ List.sublistsLen n l → l'.length = n | null | true |
Std.DTreeMap.Internal.Impl.exists_cell_of_updateCell | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Ord α] [Std.TransOrd α] [Std.LawfulBEqOrd α]
(l : Std.DTreeMap.Internal.Impl α β) (hlb : l.Balanced),
l.Ordered →
∀ (k : α) (f : Std.DTreeMap.Internal.Cell α β (compare k) → Std.DTreeMap.Internal.Cell α β (compare k)),
∃ l',
l.toListModel.Pe... | null | true |
Filter.HasBasis.pi_self | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : Type u_3} {κ : Type u_4} {f : Filter α} {p : κ → Prop} {s : κ → Set α},
f.HasBasis p s → (Filter.pi fun x => f).HasBasis (fun Ik => Ik.1.Finite ∧ p Ik.2) fun Ik => Ik.1.pi fun x => s Ik.2 | null | true |
Ordnode.isSubsetAux._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → Ordnode α → Ordnode α → Bool | null | false |
Preorder.isLimitBinaryFan | Mathlib.CategoryTheory.Limits.Preorder | {C : Type u} →
[inst : SemilatticeInf C] →
(X Y : C) →
CategoryTheory.Limits.IsLimit
(CategoryTheory.Limits.BinaryFan.mk (CategoryTheory.homOfLE ⋯) (CategoryTheory.homOfLE ⋯)) | The infimum of two elements in a preordered type is a binary product in
the category associated to this preorder. | true |
String.Slice.Pattern.Model.Char.isLongestRevMatch_iff | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatch c pos ↔
∃ (h : s.endPos ≠ s.startPos), pos = s.endPos.prev h ∧ (s.endPos.prev h).get ⋯ = c | null | true |
TopCat.Sheaf.eq_of_locally_eq | 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]... | null | true |
Lean.Meta.Grind.Arith.Linear.instHashablePoly_lean.hash._f | Lean.Meta.Tactic.Grind.Arith.Linear.Types | (x : Lean.Grind.Linarith.Poly) → Lean.Grind.Linarith.Poly.below x → UInt64 | null | false |
SSet.Truncated.instMonoidalTruncation._proof_22 | Mathlib.AlgebraicTopology.SimplicialSet.Monoidal | ∀ (n : ℕ),
autoParam
(∀ (X Y : SSet),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.OplaxMonoidal.δ (SSet.truncation n) X Y)
(CategoryTheory.Functor.LaxMonoidal.μ (SSet.truncation n) X Y) =
CategoryTheory.CategoryStruct.id
((SSet.truncation n).obj (CategoryTheory.Mon... | null | false |
Stream'.Seq.length_map | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {β : Type v} {s : Stream'.Seq α} {f : α → β} (h : (Stream'.Seq.map f s).Terminates),
(Stream'.Seq.map f s).length h = s.length ⋯ | null | true |
EckmannHilton.addCommGroup.eq_1 | Mathlib.GroupTheory.EckmannHilton | ∀ {X : Type u} {m₁ : X → X → X} {e₁ : X} (h₁ : EckmannHilton.IsUnital m₁ e₁) [G : AddGroup X]
(distrib : ∀ (a b c d : X), m₁ (a + b) (c + d) = m₁ a c + m₁ b d),
EckmannHilton.addCommGroup h₁ distrib = { toAddGroup := G, add_comm := ⋯ } | null | true |
Aesop.TraceOption.mk.inj | Aesop.Tracing | ∀ {traceClass : Lean.Name} {option : Lean.Option Bool} {traceClass_1 : Lean.Name} {option_1 : Lean.Option Bool},
{ traceClass := traceClass, option := option } = { traceClass := traceClass_1, option := option_1 } →
traceClass = traceClass_1 ∧ option = option_1 | null | true |
MvPowerSeries.coeff_truncTotal_pow | Mathlib.RingTheory.MvPowerSeries.Trunc | ∀ {σ : Type u_1} {R : Type u_2} {n m : ℕ} [inst : Finite σ] [inst_1 : CommSemiring R] (p : MvPowerSeries σ R)
{x : σ →₀ ℕ}, Finsupp.degree x < n → ((MvPowerSeries.truncTotal n) p ^ m).coeff x = (MvPowerSeries.coeff x) (p ^ m) | null | true |
SimpleGraph.Hom.instUniqueOfIsEmpty._proof_2 | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {H : SimpleGraph W} [inst : IsEmpty V] (x : G →g H),
x = { toFun := fun a => isEmptyElim a, map_rel' := ⋯ } | null | false |
_private.Mathlib.Geometry.Euclidean.Volume.Measure.0.MeasureTheory.Measure.euclideanHausdorffMeasure._proof_5 | Mathlib.Geometry.Euclidean.Volume.Measure | ∀ (d : ℕ), BorelSpace (PiLp 2 fun x => ℝ) | null | false |
CategoryTheory.ComposableArrows.IsComplex.recOn | Mathlib.Algebra.Homology.ExactSequence | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{n : ℕ} →
{S : CategoryTheory.ComposableArrows C n} →
{motive : S.IsComplex → Sort u} →
(t : S.IsComplex) →
((zero :
∀ (i : ℕ... | null | false |
Int.cast_ite._simp_1 | Mathlib.Data.Int.Cast.Basic | ∀ {R : Type u} [inst : IntCast R] (P : Prop) [inst_1 : Decidable P] (m n : ℤ),
(if P then ↑m else ↑n) = ↑(if P then m else n) | null | false |
Set.Finite.preimage | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β}, Set.InjOn f (f ⁻¹' s) → s.Finite → (f ⁻¹' s).Finite | null | true |
CategoryTheory.Limits.PreservesFiniteLimitsOfIsFilteredCostructuredArrowYonedaAux.isoAux_hom_app | Mathlib.CategoryTheory.Limits.Preserves.Presheaf | ∀ {C : Type u} [inst : CategoryTheory.SmallCategory C] [inst_1 : CategoryTheory.Limits.HasFiniteColimits C]
(A : CategoryTheory.Functor Cᵒᵖ (Type u)) {J : Type} [inst_2 : CategoryTheory.SmallCategory J]
[inst_3 : CategoryTheory.FinCategory J] (K : CategoryTheory.Functor J Cᵒᵖ),
(CategoryTheory.Limits.PreservesFin... | null | true |
NormedSpace.expSeries | Mathlib.Analysis.Normed.Algebra.Exponential | (𝕂 : Type u_1) →
(𝔸 : Type u_2) →
[inst : Field 𝕂] →
[inst_1 : Ring 𝔸] →
[inst_2 : Algebra 𝕂 𝔸] →
[inst_3 : TopologicalSpace 𝔸] → [inst_4 : IsTopologicalRing 𝔸] → FormalMultilinearSeries 𝕂 𝔸 𝔸 | `expSeries 𝕂 𝔸` is the `FormalMultilinearSeries` whose `n`-th term is the map
`(xᵢ) : 𝔸ⁿ ↦ (1/n! : 𝕂) • ∏ xᵢ`. Its sum is the exponential map `NormedSpace.exp : 𝔸 → 𝔸`. | true |
String.Slice.posGE.congr_simp | Init.Data.String.Lemmas.FindPos | ∀ (s : String.Slice) (offset offset_1 : String.Pos.Raw) (e_offset : offset = offset_1) (h : offset ≤ s.rawEndPos),
s.posGE offset h = s.posGE offset_1 ⋯ | null | true |
Bundle.TotalSpace.toProd_apply | Mathlib.Data.Bundle | ∀ (B : Type u_4) (F : Type u_5) (x : Bundle.TotalSpace F fun x => F), (Bundle.TotalSpace.toProd B F) x = (x.proj, x.snd) | null | true |
Valued.«term𝓀[_]» | Mathlib.Topology.Algebra.Valued.ValuedField | Lean.ParserDescr | An abbreviation for `IsLocalRing.ResidueField 𝒪[K]` of a `Valued` instance, enabling the
notation `𝓀[K]` for the residue field of a valued field `K`. | true |
Lean.Parser.Tactic.Grind.symApply | Init.Grind.Interactive | Lean.ParserDescr | `apply t` applies theorem `t` as a backward rule.
Only available in `sym =>` mode.
When used with `repeat`, the backward rule is cached for efficiency. | true |
Std.DTreeMap.getEntryGED | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → α → Sigma β → (a : α) × β a | Tries to retrieve the key-value pair with the smallest key that is greater than or equal to the
given key, returning `fallback` if no such pair exists.
| true |
CompHausLike.effectiveEpiStruct | Mathlib.Topology.Category.CompHausLike.EffectiveEpi | {P : TopCat → Prop} →
{B X : CompHausLike P} →
(π : X ⟶ B) → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom π) → CategoryTheory.EffectiveEpiStruct π | If `π` is a surjective morphism in `CompHausLike P`, then it is an effective epi.
| true |
CategoryTheory.Adjunction.whiskerRight_unit_iso_of_R_fully_faithful | Mathlib.CategoryTheory.Adjunction.FullyFaithful | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C} (h : L ⊣ R) [R.Full] [R.Faithful],
CategoryTheory.IsIso (CategoryTheory.Functor.whiskerRight h.unit L) | null | true |
Lean.doc.verso | Lean.DocString.Extension | Lean.Option Bool | null | true |
Matrix.smul_mulVec | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_5} {α : Type v} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Fintype n]
[inst_2 : DistribSMul R α] [IsScalarTower R α α] (b : R) (M : Matrix m n α) (v : n → α),
(b • M).mulVec v = b • M.mulVec v | null | true |
Tuple.self_comp_sort | Mathlib.Data.Fin.Tuple.Sort | ∀ {n : ℕ} {α : Type u_1} [inst : LinearOrder α] (f : Fin n → α),
f ∘ ⇑(Tuple.sort f) = Tuple.graph.proj ∘ ⇑(Tuple.graphEquiv₂ f) | null | true |
Lean.PrettyPrinter.Delaborator.failure | Lean.PrettyPrinter.Delaborator.Basic | {α : Type} → Lean.PrettyPrinter.Delaborator.DelabM α | null | true |
Int.add_of_le.congr_simp | Init.Data.Int.Cooper | ∀ {a b : ℤ} (h : a ≤ b), Int.add_of_le h = Int.add_of_le h | null | true |
MeasureTheory.lpNorm_one_eq_integral_norm | Mathlib.MeasureTheory.Function.LpSeminorm.LpNorm | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup E]
{f : α → E}, MeasureTheory.AEStronglyMeasurable f μ → MeasureTheory.lpNorm f 1 μ = ∫ (x : α), ‖f x‖ ∂μ | null | true |
_private.Mathlib.Analysis.Calculus.Taylor.0.hasDerivWithinAt_taylor_coeff_within._simp_1_1 | Mathlib.Analysis.Calculus.Taylor | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
fixedPointsSubAddOfNormal.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {G : Type u_1} [inst : AddGroup G] {α : Type u_2} [inst_1 : AddAction G α] {H : AddSubgroup G} [hH : H.Normal],
fixedPointsSubAddOfNormal = { carrier := AddAction.fixedPoints (↥H) α, vadd_mem' := ⋯ } | null | true |
CategoryTheory.ObjectProperty.instIsMultiplicativeTrWOfIsTriangulatedOfIsTriangulated | 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... | null | true |
lp.norm_mapCLM_le | Mathlib.Analysis.Normed.Lp.lpHolder | ∀ {α : Type u_1} {𝕜 : Type u_2} {E : α → Type u_3} {F : α → Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : α) → NormedAddCommGroup (E i)] [inst_2 : (i : α) → NormedSpace 𝕜 (E i)]
[inst_3 : (i : α) → NormedAddCommGroup (F i)] [inst_4 : (i : α) → NormedSpace 𝕜 (F i)] (p : ENNReal)
[inst_5 : Fact (1... | null | true |
_private.Mathlib.Algebra.Group.PNatPowAssoc.0.ppow_mul_assoc._simp_1_1 | Mathlib.Algebra.Group.PNatPowAssoc | ∀ {M : Type u_1} [inst : Mul M] [inst_1 : Pow M ℕ+] [PNatPowAssoc M] (k n : ℕ+) (x : M), x ^ k * x ^ n = x ^ (k + n) | null | false |
AlgebraicGeometry.Scheme.GlueData.ι | Mathlib.AlgebraicGeometry.Gluing | (D : AlgebraicGeometry.Scheme.GlueData) → (i : D.J) → D.U i ⟶ D.glued | The immersion from `D.U i` into the glued space. | true |
oneLePart_one | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : DivInvMonoid α], 1⁺ᵐ = 1 | null | true |
AlgebraicGeometry.PresheafedSpace.GlueData.mk.inj | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C}
{toGlueData : CategoryTheory.GlueData (AlgebraicGeometry.PresheafedSpace C)}
{f_open : ∀ (i j : toGlueData.J), AlgebraicGeometry.PresheafedSpace.IsOpenImmersion (toGlueData.f i j)}
{toGlueData_1 : CategoryTheory.GlueData (AlgebraicGeometry.PresheafedSpace C... | null | true |
Mathlib.Tactic.BicategoryLike.State.rec | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {motive : Mathlib.Tactic.BicategoryLike.State → Sort u} →
((cache : Lean.PersistentExprMap Mathlib.Tactic.BicategoryLike.Mor₁) → motive { cache := cache }) →
(t : Mathlib.Tactic.BicategoryLike.State) → motive t | null | false |
Lean.Lsp.SemanticTokenType.class.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SemanticTokenType → Sort u} →
(t : Lean.Lsp.SemanticTokenType) → t.ctorIdx = 6 → motive Lean.Lsp.SemanticTokenType.class → motive t | null | false |
Std.IterM.TerminationMeasures.Finite.casesOn | Init.Data.Iterators.Basic | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
[inst : Std.Iterator α m β] →
{motive : Std.IterM.TerminationMeasures.Finite α m → Sort u} →
(t : Std.IterM.TerminationMeasures.Finite α m) → ((it : Std.IterM m β) → motive { it := it }) → motive t | null | false |
Nat.decidableProbablePrime | Mathlib.NumberTheory.FermatPsp | (n b : ℕ) → Decidable (n.ProbablePrime b) | null | true |
UInt64.toUSize_toUInt8 | Init.Data.UInt.Lemmas | ∀ (n : UInt64), n.toUInt8.toUSize = n.toUSize % 256 | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.AppendTarget.mk.noConfusion | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append | {α : Type} →
{inst : Hashable α} →
{inst_1 : DecidableEq α} →
{aig : Std.Sat.AIG α} →
{combined : ℕ} →
{P : Sort u} →
{lw rw : ℕ} →
{lhs : aig.RefVec lw} →
{rhs : aig.RefVec rw} →
{h : combined = rw + lw} →
{lw... | null | false |
_private.Mathlib.Topology.NhdsSet.0.nhdsSet_eq_bot_iff._simp_1_3 | Mathlib.Topology.NhdsSet | ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s | null | false |
PiLp.dist_apply_le | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {p : ENNReal} {ι : Type u_2} {β : ι → Type u_4} [hp : Fact (1 ≤ p)] [inst : Fintype ι]
[inst_1 : (i : ι) → PseudoMetricSpace (β i)] (x y : PiLp p β) (i : ι), dist (x.ofLp i) (y.ofLp i) ≤ dist x y | null | true |
HahnSeries.SummableFamily.powers_of_orderTop_pos | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {R : Type u_3} [inst : AddCommMonoid Γ] [inst_1 : LinearOrder Γ] [inst_2 : IsOrderedCancelAddMonoid Γ]
[inst_3 : CommRing R] {x : HahnSeries Γ R}, 0 < x.orderTop → ∀ (n : ℕ), (HahnSeries.SummableFamily.powers x) n = x ^ n | null | true |
Std.DTreeMap.Raw.Equiv.alter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t₁.WF → t₂.WF → t₁.Equiv t₂ → ∀ (k : α) (f : Option (β k) → Option (β k)), (t₁.alter k f).Equiv (t₂.alter k f) | null | true |
AddMonoid.Coprod.inr.eq_1 | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N],
AddMonoid.Coprod.inr =
{ toFun := fun x => AddMonoid.Coprod.mk (FreeAddMonoid.of (Sum.inr x)), map_zero' := ⋯, map_add' := ⋯ } | null | true |
BitVec.reverse | Init.Data.BitVec.Basic | {w : ℕ} → BitVec w → BitVec w | Reverses the bits in a bitvector. | true |
AlgebraicGeometry.Scheme.IsSeparated.isSeparated_terminal_from | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {X : AlgebraicGeometry.Scheme} [self : X.IsSeparated],
AlgebraicGeometry.IsSeparated (CategoryTheory.Limits.terminal.from X) | null | true |
_private.Init.Data.Array.Basic.0.Array.shrink.loop._unsafe_rec | Init.Data.Array.Basic | {α : Type u} → ℕ → Array α → Array α | null | false |
Bialgebra.TensorProduct.assoc._proof_2 | Mathlib.RingTheory.Bialgebra.TensorProduct | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_4) (C : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : Semiring A] [inst_3 : Bialgebra S A] [inst_4 : Algebra R A] [inst_5 : Algebra R S]
[inst_6 : IsScalarTower R S A] [inst_7 : Semiring C] [inst_8 : Bialgebra S C], SMulCommClass R S (TensorProduct... | null | false |
Nat.IsStrongDvdSequence.eq_1 | Mathlib.Data.Nat.DvdSequence | ∀ (f : ℕ → ℕ), Nat.IsStrongDvdSequence f = ∀ (a b : ℕ), (f a).gcd (f b) = f (a.gcd b) | null | true |
_private.Std.Sat.CNF.SpecLemmas.0.Std.Do.Spec.forIn'_cnfClause._simp_3 | Std.Sat.CNF.SpecLemmas | ∀ {α : Type u_1} {c : Std.Sat.CNF.Clause α} {l : Std.Sat.Literal α}, (l ∈ c) = (l ∈ c.literals) | null | false |
SimplexCategory.δ₀Iter.congr_simp | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | ∀ (i i_1 : ℕ) (e_i : i = i_1) {n m : ℕ} (hi : n + i = m), SimplexCategory.δ₀Iter i hi = SimplexCategory.δ₀Iter i_1 ⋯ | null | true |
MeasureTheory.AEDisjoint.union_right | Mathlib.MeasureTheory.Measure.AEDisjoint | ∀ {α : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t u : Set α},
MeasureTheory.AEDisjoint μ s t → MeasureTheory.AEDisjoint μ s u → MeasureTheory.AEDisjoint μ s (t ∪ u) | null | true |
Lean.Parser.tokenAntiquotFn | Lean.Parser.Basic | Lean.Parser.ParserFn | null | true |
ProofWidgets.InteractiveMessageProps._sizeOf_1 | ProofWidgets.Component.Basic | ProofWidgets.InteractiveMessageProps → ℕ | null | false |
DivInvOneMonoid.toInvOneClass | Mathlib.Algebra.Group.DivInvMonoid | {G : Type u_2} → [self : DivInvOneMonoid G] → InvOneClass G | null | true |
SubfieldClass.instRatCast | Mathlib.Algebra.Field.Subfield.Defs | {K : Type u} →
[inst : DivisionRing K] → {S : Type u_1} → [inst_1 : SetLike S K] → [h : SubfieldClass S K] → (s : S) → RatCast ↥s | null | true |
Finset.exists_sum_fiber_lt_of_maps_to_of_sum_lt_nsmul | Mathlib.Combinatorics.Pigeonhole | ∀ {α : Type u} {β : Type v} {M : Type w} [inst : DecidableEq β] {s : Finset α} {t : Finset β} {f : α → β} {w : α → M}
{b : M} [inst_1 : AddCommMonoid M] [inst_2 : LinearOrder M] [IsOrderedCancelAddMonoid M],
(∀ a ∈ s, f a ∈ t) → ∑ x ∈ s, w x < t.card • b → ∃ y ∈ t, ∑ x ∈ s with f x = y, w x < b | The pigeonhole principle for finitely many pigeons counted by weight, strict inequality version:
if the total weight of a finite set of pigeons is less than `n • b`, and they are sorted into `n`
pigeonholes, then for some pigeonhole, the total weight of the pigeons in this pigeonhole is less
than `b`. | true |
Bundle.Trivialization.tendsto_nhds_iff | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e : Bundle.Trivialization F proj) {α : Type u_5} {l : Filter α} {f : α → Z} {z : Z},
z ∈ e.source →
(Filter.Tendsto f l (nhds z) ↔
Filter.Tendsto (proj ∘ f... | null | true |
CategoryTheory.Join.mapWhiskerLeft_whiskerRight_assoc | Mathlib.CategoryTheory.Join.Pseudofunctor | ∀ (A : Type u_1) {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] {F G : CategoryTheory.Functor B C} (η : F ⟶ G)
(H : CategoryTh... | null | true |
Std.DHashMap.isEmpty_erase | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α}, (m.erase k).isEmpty = (m.isEmpty || m.size == 1 && m.contains k) | null | true |
Std.ExtDHashMap.getKey!_insertIfNew | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {k a : α} {v : β k},
(m.insertIfNew k v).getKey! a = if (k == a) = true ∧ k ∉ m then k else m.getKey! a | null | true |
Finset.finsuppAntidiagEquivSubtype._proof_1 | Mathlib.Algebra.Order.Antidiag.FinsuppEquiv | ∀ {ι : Type u_2} {μ : Type u_1} [inst : DecidableEq ι] [inst_1 : AddCommMonoid μ] [inst_2 : Finset.HasAntidiagonal μ]
[inst_3 : DecidableEq μ] (s : Finset ι) (n : μ) (f : ↥(s.finsuppAntidiag n)),
((Finsupp.subtypeDomain (fun x => x ∈ s) ↑f).sum fun x => id) = n | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.shiftLeft_add._proof_1_5 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (n m i : ℕ), i < w → w ≤ i - m → i - m < n → n + m ≤ i → False | null | false |
Profinite.NobelingProof.instSubsingletonLocallyConstantElemForallBoolEmptyCollectionSetInt | Mathlib.Topology.Category.Profinite.Nobeling.ZeroLimit | ∀ {I : Type u}, Subsingleton (LocallyConstant ↑∅ ℤ) | null | true |
CategoryTheory.ObjectProperty.IsClosedUnderFiniteCoproducts.of_isClosedUnderColimitsOfShape | Mathlib.CategoryTheory.ObjectProperty.FiniteProducts | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.ObjectProperty C},
(∀ (J : Type w) [Finite J], P.IsClosedUnderColimitsOfShape (CategoryTheory.Discrete J)) →
P.IsClosedUnderFiniteCoproducts | `IsClosedUnderFiniteProducts` may be checked at any universe. | true |
FiniteField.ringEquivOfCardEq._proof_2 | Mathlib.FieldTheory.Finite.GaloisField | ∀ {K : Type u_1} [inst : Fintype K] (p : ℕ) (n : ℕ+), Nat.Prime p ∧ Fintype.card K = p ^ ↑n → Fact (Nat.Prime p) | null | false |
_private.Mathlib.Analysis.BoxIntegral.UnitPartition.0.BoxIntegral.le_hasIntegralVertices_of_isBounded._simp_1_4 | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] [AddLeftMono α] {a b : α} [AddRightMono α],
(|a| < b) = (-b < a ∧ a < b) | null | false |
CategoryTheory.isArtinianObject_iff_antitone_chain_condition | Mathlib.CategoryTheory.Subobject.ArtinianObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
CategoryTheory.IsArtinianObject X ↔ ∀ (f : ℕ →o (CategoryTheory.Subobject X)ᵒᵈ), ∃ n, ∀ (m : ℕ), n ≤ m → f n = f m | null | true |
Int.negSucc_emod_ofNat | Init.Data.Int.DivMod.Basic | ∀ {a b : ℕ}, Int.negSucc a % ↑b = Int.subNatNat b (a % b).succ | null | true |
Finset.mulETransformRight.eq_1 | Mathlib.Combinatorics.Additive.ETransform | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Group α] (e : α) (x : Finset α × Finset α),
Finset.mulETransformRight e x = (x.1 ∪ MulOpposite.op e • x.1, x.2 ∩ e⁻¹ • x.2) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.