name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
UniformFun.ofFun_toFun | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_1} {β : Type u_2} (f : UniformFun α β), UniformFun.ofFun (UniformFun.toFun f) = f | null | true |
UniformSpace.metricSpace | Mathlib.Topology.Metrizable.Uniformity | (X : Type u_2) → [inst : UniformSpace X] → [(uniformity X).IsCountablyGenerated] → [T0Space X] → MetricSpace X | A `MetricSpace` instance compatible with a given `UniformSpace` structure. | true |
_private.Lean.Meta.Match.SimpH.0.Lean.Meta.Match.SimpH.State.mk.sizeOf_spec | Lean.Meta.Match.SimpH | ∀ (mvarId : Lean.MVarId) (xs eqs eqsNew : List Lean.FVarId),
sizeOf { mvarId := mvarId, xs := xs, eqs := eqs, eqsNew := eqsNew } =
1 + sizeOf mvarId + sizeOf xs + sizeOf eqs + sizeOf eqsNew | null | true |
AddEquiv.mulOp_symm_apply | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {α : Type u_3} {β : Type u_4} [inst : Add α] [inst_1 : Add β] (f : αᵐᵒᵖ ≃+ βᵐᵒᵖ),
AddEquiv.mulOp.symm f = MulOpposite.opAddEquiv.trans (f.trans MulOpposite.opAddEquiv.symm) | null | true |
Lean.Data.AC.eval.eq_2 | Init.Data.AC | ∀ {α : Sort u_1} (β : Sort u) [inst : Lean.Data.AC.EvalInformation α β] (ctx : α) (l r : Lean.Data.AC.Expr),
Lean.Data.AC.eval β ctx (l.op r) =
Lean.Data.AC.EvalInformation.evalOp ctx (Lean.Data.AC.eval β ctx l) (Lean.Data.AC.eval β ctx r) | null | true |
_aux_Mathlib_Data_PFun___unexpand_PFun_1 | Mathlib.Data.PFun | Lean.PrettyPrinter.Unexpander | null | false |
FreeGroup.IsCyclicallyReduced.nil | Mathlib.GroupTheory.FreeGroup.CyclicallyReduced | ∀ {α : Type u}, FreeGroup.IsCyclicallyReduced [] | null | true |
AlgebraicGeometry.tilde.instModuleCarrierCarrierStalkAbPresheaf | Mathlib.AlgebraicGeometry.Modules.Tilde | {R : CommRingCat} →
(M : ModuleCat ↑R) →
(x : ↑(AlgebraicGeometry.PrimeSpectrum.Top ↑R)) → Module ↑R ↑((AlgebraicGeometry.tilde M).presheaf.stalk x) | null | true |
BitVec.instMod | Init.Data.BitVec.Basic | {n : ℕ} → Mod (BitVec n) | null | true |
MulOpposite.opUniformEquiv_apply | Mathlib.Topology.UniformSpace.Equiv | ∀ {α : Type u} [inst : UniformSpace α] (a : α), MulOpposite.opUniformEquiv a = MulOpposite.op a | null | true |
Lean.Elab.Command.InductiveElabStep2.collectUsedFVars | Lean.Elab.MutualInductive | Lean.Elab.Command.InductiveElabStep2 → StateRefT' IO.RealWorld Lean.CollectFVars.State Lean.MetaM Unit | Function to collect additional fvars that might be missed by the constructors.
It is permissible to include fvars that do not exist in the local context (`structure` for example includes its field fvars). | true |
Lean.Meta.Grind.Arith.Cutsat.isSupportedType | Lean.Meta.Tactic.Grind.Arith.Cutsat.Util | Lean.Expr → Lean.Meta.Grind.GoalM Bool | Returns `true` if cutsat natively supports `type`. | true |
UInt64.neg_one_shiftLeft_and_shiftLeft | Init.Data.UInt.Bitwise | ∀ {a b : UInt64}, (-1) <<< b &&& a <<< b = a <<< b | null | true |
_private.Mathlib.CategoryTheory.Limits.Types.Pullbacks.0.CategoryTheory.Limits.Types.isPullback_iff._proof_1_4 | Mathlib.CategoryTheory.Limits.Types.Pullbacks | ∀ {X₂ X₃ X₄ : Type u_1} (r : X₂ ⟶ X₄) (b : X₃ ⟶ X₄) (x : CategoryTheory.Limits.Types.PullbackObj r b),
(CategoryTheory.ConcreteCategory.hom r) (↑x).1 = (CategoryTheory.ConcreteCategory.hom b) (↑x).2 | null | false |
List.zipWithM.match_1.congr_eq_1 | Init.Data.List.Monadic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (motive : List α → List β → Array γ → Sort u_4) (x : List α)
(x_1 : List β) (x_2 : Array γ)
(h_1 : (a : α) → (as : List α) → (b : β) → (bs : List β) → (acc : Array γ) → motive (a :: as) (b :: bs) acc)
(h_2 : (x : List α) → (x_3 : List β) → (acc : Array γ) → motive x ... | null | true |
intervalIntegral.integral_hasStrictDerivAt_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 → HasStrictDerivAt (fun u => ∫ (x : ℝ) in a..u, f x) (f b) b | **Fundamental theorem of calculus-1**, strict differentiability in the right endpoint.
If `f : ℝ → E` is integrable on `a..b` and `f` is continuous at `b`, then `u ↦ ∫ x in a..u, f x` has
derivative `f b` at `b` in the sense of strict differentiability. | true |
CategoryTheory.CreatesLimitsOfSize.CreatesLimitsOfShape._autoParam | Mathlib.CategoryTheory.Limits.Creates | Lean.Syntax | null | false |
CategoryTheory.FreeMonoidalCategory.Hom.recOn | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} →
{motive : (a a_1 : CategoryTheory.FreeMonoidalCategory C) → a.Hom a_1 → Sort u_1} →
{a a_1 : CategoryTheory.FreeMonoidalCategory C} →
(t : a.Hom a_1) →
((X : CategoryTheory.FreeMonoidalCategory C) → motive X X (CategoryTheory.FreeMonoidalCategory.Hom.id X)) →
((X Y Z : Categ... | null | false |
_private.Init.Data.List.Impl.0.List.eraseIdxTR.go | Init.Data.List.Impl | {α : Type u_1} → List α → List α → ℕ → Array α → List α | Auxiliary for `eraseIdxTR`: `eraseIdxTR.go l n xs acc = acc.toList ++ eraseIdx xs a`,
unless `a` is not present in which case it returns `l` | true |
CategoryTheory.Cat.Hom.instCategory._proof_1 | Mathlib.CategoryTheory.Category.Cat | ∀ {X Y : CategoryTheory.Cat} {X_1 Y_1 : X ⟶ Y} (η : X_1 ⟶ Y_1),
CategoryTheory.NatTrans.toCatHom₂
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.NatTrans.toCatHom₂ (CategoryTheory.CategoryStruct.id X_1.toFunctor)).toNatTrans η.toNatTrans) =
CategoryTheory.NatTrans.toCatHom₂ η.toNatTrans | null | false |
BitVec.getElem_extractLsb' | Init.Data.BitVec.Lemmas | ∀ {n start len : ℕ} {x : BitVec n} {i : ℕ} (h : i < len), (BitVec.extractLsb' start len x)[i] = x.getLsbD (start + i) | null | true |
CategoryTheory.Pretriangulated.Triangle.shiftFunctorAdd'_hom_app_hom₃ | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] (a b n : ℤ)
(h : a + b = n) (X : CategoryTheory.Pretriangulated.Triangle C),
((CategoryTheory.Pretriangulated.Tri... | null | true |
Lean.Meta.mkSimpAttr | Lean.Meta.Tactic.Simp.Attr | Lean.Name → String → Lean.Meta.SimpExtension → autoParam Lean.Name Lean.Meta.mkSimpAttr._auto_1 → IO Unit | null | true |
Polynomial.lifts_and_degree_eq_and_monic | Mathlib.Algebra.Polynomial.Lifts | ∀ {R : Type u} [inst : Semiring R] {S : Type v} [inst_1 : Semiring S] {f : R →+* S} [Nontrivial S] {p : Polynomial S},
p ∈ Polynomial.lifts f → p.Monic → ∃ q, Polynomial.map f q = p ∧ q.degree = p.degree ∧ q.Monic | A monic polynomial lifts if and only if it can be lifted to a monic polynomial
of the same degree. | true |
AddSubmonoid.map._proof_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_3}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (S : AddSubmonoid M), ∃ a ∈ ↑S, f a = 0 | null | false |
_private.Init.Data.List.Find.0.List.finIdxOf?_eq_pmap_idxOf?._simp_1_5 | Init.Data.List.Find | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.RegularizedHypergeometric.0.Complex.regularizedHGFunCoeff_add_one_div_self._simp_1_3 | Mathlib.Analysis.SpecialFunctions.RegularizedHypergeometric | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
instCompactlyGeneratedSpaceSigma | Mathlib.Topology.Compactness.CompactlyGeneratedSpace | ∀ {ι : Type u} {X : ι → Type v} [inst : (i : ι) → TopologicalSpace (X i)] [∀ (i : ι), CompactlyGeneratedSpace (X i)],
CompactlyGeneratedSpace ((i : ι) × X i) | The sigma type associated to a family of compactly generated spaces is compactly generated. | true |
Algebra.Etale.formallyEtale._autoParam | Mathlib.RingTheory.Etale.Basic | Lean.Syntax | null | false |
CategoryTheory.Over.iteratedSliceEquivOverMapIso._proof_6 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {X : T} {f g : CategoryTheory.Over X} (p : f ⟶ g)
{X_1 Y : CategoryTheory.Over f} (f_1 : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp
((f.iteratedSliceForward.comp
((CategoryTheory.Over.map (CategoryTheory.Over.Hom.left p)).comp g.iter... | null | false |
ZFSet.Insert.match_3 | Mathlib.SetTheory.ZFC.Basic | ∀ («Type» : Type u_1) (Func : «Type» → PSet.{u_1}) (motive : Option { «Type» := «Type», Func := Func }.Type → Prop)
(o : Option { «Type» := «Type», Func := Func }.Type),
(∀ (a : { «Type» := «Type», Func := Func }.Type), motive (some a)) → (∀ (_ : Unit), motive none) → motive o | null | false |
pNilradical | Mathlib.FieldTheory.IsPerfectClosure | (R : Type u_1) → [inst : CommSemiring R] → ℕ → Ideal R | Given a natural number `p`, the `p`-nilradical of a ring is defined to be the
nilradical if `p > 1` (`pNilradical_eq_nilradical`), and defined to be the zero ideal if `p ≤ 1`
(`pNilradical_eq_bot'`). Equivalently, it is the ideal consisting of elements `x` such that
`x ^ p ^ n = 0` for some `n` (`mem_pNilradical`). | true |
Finset.monoid._proof_2 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Monoid α] (s t : Finset α), ↑(s * t) = ↑s * ↑t | null | false |
Group.ofLeftAxioms._proof_2 | Mathlib.Algebra.Group.MinimalAxioms | ∀ {G : Type u_1} [inst : Mul G] [inst_1 : One G] (assoc : ∀ (a b c : G), a * b * c = a * (b * c)) (x : G), x ^ 0 = 1 | null | false |
_private.Mathlib.RingTheory.Spectrum.Maximal.Localization.0.MaximalSpectrum.toPiLocalization_not_surjective_of_infinite._simp_1_3 | Mathlib.RingTheory.Spectrum.Maximal.Localization | ∀ {ι : Type u_4} {R : ι → Type u_5} [inst : (i : ι) → CommSemiring (R i)] {i : ι} (I : Ideal (R i)) [inst_1 : I.IsPrime]
{r : (i : ι) → R i},
(algebraMap (R i) (Localization.AtPrime I)) (r i) =
(Localization.AtPrime.mapPiEvalRingHom I)
((algebraMap ((i : ι) → R i) (Localization.AtPrime (Ideal.comap (Pi.ev... | null | false |
SetLike.pow_mem_graded._f | Mathlib.Algebra.GradedMonoid | ∀ {ι : Type u_1} {R : Type u_2} {S : Type u_3} [inst : SetLike S R] [inst_1 : Monoid R] [inst_2 : AddMonoid ι]
{A : ι → S} [SetLike.GradedMonoid A] {r : R} {i : ι}, r ∈ A i → ∀ (n : ℕ) (f : Nat.below n), r ^ n ∈ A (n • i) | null | false |
BotHom.symm_dual_id | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} [inst : LE α] [inst_1 : OrderBot α], BotHom.dual.symm (TopHom.id αᵒᵈ) = BotHom.id α | null | true |
Erased.mk_inj._simp_1 | Init.Data.Erased | ∀ {α : Sort u} {a b : α}, (Erased.mk a = Erased.mk b) = (a = b) | null | false |
Std.Http.URI.instBEqAuthority | Std.Http.Data.URI.Basic | BEq Std.Http.URI.Authority | null | true |
ComplexShape.not_rel_of_eq | Mathlib.Algebra.Homology.HasNoLoop | ∀ {ι : Type u_1} (c : ComplexShape ι) [c.HasNoLoop] {j j' : ι}, j = j' → ¬c.Rel j j' | null | true |
CategoryTheory.MonoOver.full_exists | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasImages C]
(f : X ⟶ Y) [CategoryTheory.Mono f], (CategoryTheory.MonoOver.exists f).Full | null | true |
_private.Mathlib.Tactic.Basify.Attr.0.Mathlib.Tactic.Basify.explicitArgs.match_1 | Mathlib.Tactic.Basify.Attr | (motive : Option (Lean.Expr × Subarray Lean.Expr) → Sort u_1) →
(x : Option (Lean.Expr × Subarray Lean.Expr)) →
(Unit → motive none) → ((a : Lean.Expr) → (s' : Subarray Lean.Expr) → motive (some (a, s'))) → motive x | null | false |
Ideal.Quotient.mkₐ_toRingHom | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R₁ : Type u_1) {A : Type u_3} [inst : CommSemiring R₁] [inst_1 : Ring A] [inst_2 : Algebra R₁ A] (I : Ideal A)
[inst_3 : I.IsTwoSided], (Ideal.Quotient.mkₐ R₁ I).toRingHom = Ideal.Quotient.mk I | null | true |
Algebra.adjoin.powerBasisAux._proof_4 | Mathlib.RingTheory.Adjoin.PowerBasis | ∀ {K : Type u_2} {S : Type u_1} [inst : Field K] [inst_1 : CommRing S] [inst_2 : Algebra K S],
AddSubmonoidClass (Subalgebra K S) S | null | false |
Std.Tactic.BVDecide.Normalize.BitVec.zero_shiftLeft' | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {w w' : ℕ} (n : BitVec w), 0#w' <<< n = 0#w' | null | true |
ContinuousLinearEquiv.toContinuousAffineEquiv._proof_1 | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ {k : Type u_3} [inst : Ring k] {E : Type u_1} {F : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module k E]
[inst_3 : TopologicalSpace E] [inst_4 : AddCommGroup F] [inst_5 : Module k F] [inst_6 : TopologicalSpace F]
(L : E ≃L[k] F), Continuous (↑↑L).toFun | null | false |
WithTop.untopD_le | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : PartialOrder α] {y : WithTop α} {a b : α}, y ≤ ↑b → WithTop.untopD a y ≤ b | null | true |
SkewMonoidAlgebra.liftNC_single | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {R : Type u_5} [inst_1 : NonUnitalNonAssocSemiring R]
(f : k →+ R) (g : G → R) (a : G) (b : k), (SkewMonoidAlgebra.liftNC f g) (SkewMonoidAlgebra.single a b) = f b * g a | null | true |
LinearMap.IsSymmetric.iSup_eigenspace_inf_eigenspace_of_commute | Mathlib.Analysis.InnerProductSpace.JointEigenspace | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{α : 𝕜} {A B : E →ₗ[𝕜] E} [FiniteDimensional 𝕜 E],
B.IsSymmetric → Commute A B → ⨆ γ, Module.End.eigenspace A α ⊓ Module.End.eigenspace B γ = Module.End.eigenspace A α | If A and B are commuting symmetric operators on a finite-dimensional inner product space
then the eigenspaces of the restriction of B to any eigenspace of A exhaust that eigenspace. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_union_of_contains_eq_false_right._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
ContinuousMap.HomotopyWith.Simps.apply | Mathlib.Topology.Homotopy.Basic | {X : Type u} →
{Y : Type v} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{f₀ f₁ : C(X, Y)} → {P : C(X, Y) → Prop} → f₀.HomotopyWith f₁ P → ↑unitInterval × X → Y | See Note [custom simps projection]. We need to specify this projection explicitly in this case,
because it is a composition of multiple projections. | true |
Std.ExtTreeMap.getKeyLE | Std.Data.ExtTreeMap.Basic | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
[inst : Std.TransCmp cmp] → (t : Std.ExtTreeMap α β cmp) → (k : α) → (∃ a ∈ t, (cmp a k).isLE = true) → α | Given a proof that such a mapping exists, retrieves the largest key that is
less than or equal to the given key.
| true |
MeasureTheory.Measure.inv.instIsMulRightInvariant | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : DivisionMonoid G] [MeasurableMul G] [MeasurableInv G]
{μ : MeasureTheory.Measure G} [μ.IsMulLeftInvariant], μ.inv.IsMulRightInvariant | null | true |
instT2SpaceTangentSpace | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : 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] {x : M}, T2Space (TangentSpace I x) | null | true |
_private.Mathlib.NumberTheory.Harmonic.ZetaAsymp.0.completedRiemannZeta_conj_of_re_pos | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ {s : ℂ}, 0 < s.re → completedRiemannZeta ((starRingEnd ℂ) s) = (starRingEnd ℂ) (completedRiemannZeta s) | **Conjugation symmetry of the completed zeta function** for `0 < re s`, where the
relation `Λ s = ζ s * Γ_ℝ s` is available. | true |
Lean.Parser.Term.mdataDiagnostic | Lean.Parser.Term | Lean.Parser.Parser | Representation of an expression with metadata used during pretty printing for the `pp.mdata` option.
| true |
Lean.Parser.Tactic.allGoals | Init.Tactics | Lean.ParserDescr | `all_goals tac` runs `tac` on each goal, concatenating the resulting goals.
If the tactic fails on any goal, the entire `all_goals` tactic fails.
See also `any_goals tac`.
| true |
Bundle.RiemannianMetric.casesOn | Mathlib.Topology.VectorBundle.Riemannian | {B : Type u_4} →
{E : B → Type u_6} →
[inst : (b : B) → TopologicalSpace (E b)] →
[inst_1 : (b : B) → AddCommGroup (E b)] →
[inst_2 : (b : B) → Module ℝ (E b)] →
{motive : Bundle.RiemannianMetric E → Sort u} →
(t : Bundle.RiemannianMetric E) →
((inner : (b : B) → ... | null | false |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardPattern.0.String.Slice.Pos.revSkipWhile._unary.eq_def | Init.Data.String.Lemmas.Pattern.String.ForwardPattern | ∀ {ρ : Type} {s : String.Slice} (pat : ρ) [inst : String.Slice.Pattern.BackwardPattern pat] (pos : s.Pos),
String.Slice.Pos.revSkipWhile._unary pat pos =
match pos.revSkip? pat with
| some nextCurr => if nextCurr < pos then String.Slice.Pos.revSkipWhile._unary pat nextCurr else pos
| none => pos | null | false |
isωSup_ωSup | Mathlib.Topology.OmegaCompletePartialOrder | ∀ {α : Type u_1} [inst : OmegaCompletePartialOrder α] (c : OmegaCompletePartialOrder.Chain α),
Scott.IsωSup c (OmegaCompletePartialOrder.ωSup c) | null | true |
AddCommGrpCat.ofHom | Mathlib.Algebra.Category.Grp.Basic | {X Y : Type u} → [inst : AddCommGroup X] → [inst_1 : AddCommGroup Y] → (X →+ Y) → (↧X ⟶ ↧Y) | Typecheck an `AddMonoidHom` as a morphism in `AddCommGrpCat`. | true |
CategoryTheory.SingleObj.differenceFunctor_obj | Mathlib.CategoryTheory.SingleObj | ∀ {G : Type u} [inst : Group G] {C : Type v} [inst_1 : CategoryTheory.Category.{w, v} C] (f : C → G) (x : C),
(CategoryTheory.SingleObj.differenceFunctor f).obj x = () | null | true |
CategoryTheory.ComposableArrows.homMk₅._proof_6 | Mathlib.CategoryTheory.ComposableArrows.Basic | 5 < 5 + 1 | null | false |
String.Slice.Pos.lt_next_iff_le | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p q : s.Pos} {h : q ≠ s.endPos}, p < q.next h ↔ p ≤ q | null | true |
Lean.PrettyPrinter.Parenthesizer.Context.mk.inj | Lean.PrettyPrinter.Parenthesizer | ∀ {cat : Lean.Name} {forceParens : Bool} {cat_1 : Lean.Name} {forceParens_1 : Bool},
{ cat := cat, forceParens := forceParens } = { cat := cat_1, forceParens := forceParens_1 } →
cat = cat_1 ∧ forceParens = forceParens_1 | null | true |
Int.tmod_tmod_of_dvd | Init.Data.Int.DivMod.Lemmas | ∀ (n : ℤ) {m k : ℤ}, m ∣ k → (n.tmod k).tmod m = n.tmod m | null | true |
Fin.prod_univ_two' | Mathlib.Algebra.BigOperators.Fin | ∀ {ι : Type u_1} {M : Type u_2} [inst : CommMonoid M] (f : ι → M) (a b : ι), ∏ i, f (![a, b] i) = f a * f b | null | true |
Lean.IR.EmitLLVM.emitJp | Lean.Compiler.IR.EmitLLVM | {llvmctx : Lean.LLVM.Context} → Lean.IR.JoinPointId → Lean.IR.EmitLLVM.M llvmctx (Lean.LLVM.BasicBlock llvmctx) | null | true |
ENNReal.tsum_eq_limsup_sum_nat | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {f : ℕ → ENNReal}, ∑' (i : ℕ), f i = Filter.limsup (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop | null | true |
Std.Http.Body.Stream.rec | Std.Http.Data.Body.Stream | {motive : Std.Http.Body.Stream → Sort u} →
((state : Std.Mutex Std.Http.Body.Channel.State✝) → motive { state := state }) → (t : Std.Http.Body.Stream) → motive t | null | false |
NumberField.mixedEmbedding.fundamentalCone.expMap_smul | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (c : ℝ) (x : NumberField.mixedEmbedding.realSpace K),
↑NumberField.mixedEmbedding.fundamentalCone.expMap (c • x) = ↑NumberField.mixedEmbedding.fundamentalCone.expMap x ^ c | null | true |
Prod.instStarMul._proof_1 | Mathlib.Algebra.Star.Prod | ∀ {R : Type u_1} {S : Type u_2} [inst : Mul R] [inst_1 : Mul S] [inst_2 : StarMul R] [inst_3 : StarMul S]
(x x_1 : R × S), star (x * x_1) = star x_1 * star x | null | false |
instLawfulOrderLTInt64 | Init.Data.SInt.Lemmas | Std.LawfulOrderLT Int64 | null | true |
Lean.Meta.Occurrences.pos.injEq | Init.MetaTypes | ∀ (idxs idxs_1 : List ℕ), (Lean.Meta.Occurrences.pos idxs = Lean.Meta.Occurrences.pos idxs_1) = (idxs = idxs_1) | null | true |
IsMaxOn.bddAbove | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {s : Set α} {a : α}, IsMaxOn f s a → BddAbove (f '' s) | null | true |
CategoryTheory.biproduct_ι_comp_leftDistributor_hom_assoc | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts C] {J : Type} [inst_5 : Finite J] (X : C) (f : J → C) (j : J)
{Z :... | null | true |
MeasureTheory.exists_measure_symmDiff_lt_of_generateFrom_isSetSemiring | Mathlib.MeasureTheory.Measure.MeasuredSets | ∀ {α : Type u_1} [mα : MeasurableSpace α] {μ : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ]
{C : Set (Set α)},
MeasureTheory.IsSetSemiring C →
(∃ D, D.Countable ∧ D ⊆ C ∧ μ (⋃₀ D)ᶜ = 0) →
mα = MeasurableSpace.generateFrom C →
∀ {s : Set α}, MeasurableSet s → ∀ {ε : ENNReal}, 0 < ε → ... | Given a semiring of sets `C` covering the space modulo `0` and generating the measurable space
structure, any measurable set can be approximated by finite unions of elements of `C`. | true |
NonemptyInterval.coe_top | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : BoundedOrder α], ↑⊤ = Set.univ | null | true |
eq_const_of_unique | Mathlib.Basic.Unique | ∀ {α : Sort u_1} {β : Sort u_2} [inst : Unique α] (f : α → β), f = Function.const α (f default) | null | true |
Affine.Simplex.exradius.congr_simp | Mathlib.Geometry.Euclidean.Incenter.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s s_1 : Affine.Simplex ℝ P n),
s = s_1 → ∀ (signs signs_1 : Finset (Fin (n + 1))), signs = signs_1 → s.exradius signs = s_1.exradius sig... | null | true |
Std.TreeSet.Equiv.atIdxD_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {i : ℕ} {fallback : α},
t₁.Equiv t₂ → t₁.atIdxD i fallback = t₂.atIdxD i fallback | null | true |
IsLocalization.algEquivOfAlgEquiv_eq_map | Mathlib.RingTheory.Localization.Basic | ∀ {A : Type u_4} [inst : CommSemiring A] {R : Type u_5} [inst_1 : CommSemiring R] [inst_2 : Algebra A R]
{M : Submonoid R} {S : Type u_6} [inst_3 : CommSemiring S] [inst_4 : Algebra A S] [inst_5 : Algebra R S]
[inst_6 : IsScalarTower A R S] [inst_7 : IsLocalization M S] {P : Type u_7} [inst_8 : CommSemiring P]
[i... | null | true |
Tactic.ComputeAsymptotics.UnitMonomial.FirstNonzeroIsNeg.not_FirstNonzeroIsPos | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Predicates | ∀ {li : Tactic.ComputeAsymptotics.UnitMonomial}, li.FirstNonzeroIsNeg → ¬li.FirstNonzeroIsPos | null | true |
_private.Mathlib.NumberTheory.FundamentalDiscriminant.0.Int.isFundamentalDiscr_iff_forall_prime._simp_1_3 | Mathlib.NumberTheory.FundamentalDiscriminant | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
Lean.IRPhases.recOn | Lean.Setup | {motive : Lean.IRPhases → Sort u} →
(t : Lean.IRPhases) →
motive Lean.IRPhases.runtime → motive Lean.IRPhases.comptime → motive Lean.IRPhases.all → motive t | null | false |
Std.DHashMap.Internal.Raw₀.Const.get!_of_isEmpty | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α] [inst_4 : Inhabited β],
(↑m).WF → ∀ {a : α}, (↑m).isEmpty = true → Std.DHashMap.Internal.Raw₀.Const.get! m a = default | null | true |
ContinuousAffineMap.decompContinuousAffineEquiv._proof_2 | Mathlib.Topology.Algebra.ContinuousAffineMap.Topology | ∀ (R : Type u_4) (V : Type u_2) {W : Type u_3} (Q : Type u_1) [inst : NormedField R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace V] [inst_4 : AddCommGroup W] [inst_5 : Module R W]
[inst_6 : TopologicalSpace W] [inst_7 : AddTorsor W Q] [inst_8 : TopologicalSpace Q]
[inst_9 : IsTopolo... | null | false |
Lean.Elab.InlayHintInfo.textEdits | Lean.Elab.InfoTree.InlayHints | Lean.Elab.InlayHintInfo → Array Lean.Elab.InlayHintTextEdit | null | true |
Orientation.kahler_rightAngleRotation_right | 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.kahler x) (o.rightAngleRotation y) = Complex.I * (o.kahler x) y | null | true |
CategoryTheory.MorphismProperty.Arrow.Hom.mk_hom | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P Q W : CategoryTheory.MorphismProperty T}
[inst_1 : Q.IsMultiplicative] [inst_2 : W.IsMultiplicative] {A B : P.Arrow Q W}
(f :
(CategoryTheory.MorphismProperty.Arrow.forget P Q W).obj A ⟶
(CategoryTheory.MorphismProperty.Arrow.forget P Q W).... | null | true |
_private.Mathlib.AlgebraicGeometry.Scheme.0.AlgebraicGeometry.instIsIsoSchemeMapOfCommRingCat._proof_1 | Mathlib.AlgebraicGeometry.Scheme | ∀ {R S : CommRingCat} (f : R ⟶ S) [CategoryTheory.IsIso f], CategoryTheory.IsIso (AlgebraicGeometry.Spec.map f) | null | false |
CategoryTheory.Square.noConfusionType | Mathlib.CategoryTheory.Square | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.Square C →
{C' : Type u} → [inst' : CategoryTheory.Category.{v, u} C'] → CategoryTheory.Square C' → Sort u_1 | null | false |
LinearMap.zero_apply | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {M : Type u_8} {M₂ : Type u_10} [inst : Semiring R₁] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R₁ M] [inst_5 : Module R₂ M₂]
{σ₁₂ : R₁ →+* R₂} (x : M), 0 x = 0 | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.keyAtIdx_eq._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
IsUnit.mul_right_dvd._simp_1 | Mathlib.Algebra.Divisibility.Units | ∀ {α : Type u_1} [inst : Monoid α] {a b u : α}, IsUnit u → (a * u ∣ b) = (a ∣ b) | null | false |
instSliceableListSliceNat_5 | Init.Data.Slice.List.Basic | {α : Type u} → Std.Roi.Sliceable (ListSlice α) ℕ (ListSlice α) | null | true |
Int.Internal.Linear.dvd_unsat | Init.Data.Int.Linear | ∀ (ctx : Int.Internal.Linear.Context) (k : ℤ) (p : Int.Internal.Linear.Poly),
Int.Internal.Linear.Poly.isUnsatDvd k p = true → k ∣ Int.Internal.Linear.Poly.denote' ctx p → False | null | true |
_private.Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula.0.ModularForm.eq_zero_of_pow_eq_smul | Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula | ∀ {p p4 p6 : PowerSeries ℂ} {c4 c6 : ℂ},
(PowerSeries.coeff 0) p4 = 1 →
(PowerSeries.coeff 0) p6 = 1 →
(PowerSeries.coeff 1) p4 = 240 → (PowerSeries.coeff 1) p6 = -504 → c4 • p4 = p ^ 2 → c6 • p6 = p ^ 3 → p = 0 | null | true |
HomotopicalAlgebra.FibrantObject.instIsFibrantObjι | Mathlib.AlgebraicTopology.ModelCategory.Bifibrant | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithFibrations C]
[inst_2 : CategoryTheory.Limits.HasTerminal C] (X : HomotopicalAlgebra.FibrantObject C),
HomotopicalAlgebra.IsFibrant (HomotopicalAlgebra.FibrantObject.ι.obj X) | null | true |
USize.zero_shiftLeft | Init.Data.UInt.Bitwise | ∀ {a : USize}, 0 <<< a = 0 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.