name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Batteries.Tactic.getExplicitRelArg?._sunfold | Batteries.Tactic.Trans | Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM (Option (Lean.Expr × Lean.Expr)) |
Real.rpow_sum_le_const_mul_sum_rpow_of_nonneg | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u} (s : Finset ι) {f : ι → ℝ} {p : ℝ},
1 ≤ p → (∀ i ∈ s, 0 ≤ f i) → (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p |
String.Pos.Raw.byteIdx_add_string | Init.Data.String.PosRaw | ∀ {p : String.Pos.Raw} {s : String}, (p + s).byteIdx = p.byteIdx + s.utf8ByteSize |
MonCat.Colimits.colimitIsColimit._proof_2 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (F : CategoryTheory.Functor J MonCat)
(s : CategoryTheory.Limits.Cocone F) (m : (MonCat.Colimits.colimitCocone F).pt ⟶ s.pt),
(∀ (j : J), CategoryTheory.CategoryStruct.comp ((MonCat.Colimits.colimitCocone F).ι.app j) m = s.ι.app j) →
m = MonCat.Colimits.descMorphism F s |
instHasColimitsOfShapeUnderOfWithInitial | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type w} [inst_1 : CategoryTheory.Category.{w', w} J]
(X : C) [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.WithInitial J) C],
CategoryTheory.Limits.HasColimitsOfShape J (CategoryTheory.Under X) |
ContMDiffAt.curry_left | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {F : Type u_8}
[inst_11 : NormedAddCommGroup F] [inst_12 : NormedSpace 𝕜 F] {G : Type u_9} [inst_13 : TopologicalSpace G]
{J : ModelWithCorners 𝕜 F G} {N : Type u_10} [inst_14 : TopologicalSpace N] [inst_15 : ChartedSpace G N]
{n : WithTop ℕ∞} {f : M → M' → N} {x : M} {y : M'},
ContMDiffAt (I.prod I') J n (Function.uncurry f) (x, y) → ContMDiffAt I J n (fun x => f x y) x |
LaurentPolynomial.degree_zero | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R], LaurentPolynomial.degree 0 = ⊥ |
_private.Std.Tactic.BVDecide.LRAT.Internal.CompactLRATCheckerSound.0.Std.Tactic.BVDecide.LRAT.Internal.compactLratChecker.go.match_1.splitter | Std.Tactic.BVDecide.LRAT.Internal.CompactLRATCheckerSound | {n : ℕ} →
(motive : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n × Bool → Sort u_1) →
(x : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n × Bool) →
((fst : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n) →
(checkSuccess : Bool) → motive (fst, checkSuccess)) →
motive x |
PNat.factorMultiset.eq_1 | Mathlib.Data.PNat.Factors | ∀ (n : ℕ+), n.factorMultiset = PrimeMultiset.ofNatList (↑n).primeFactorsList ⋯ |
CategoryTheory.Grothendieck.instCategory._proof_3 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (f : X.Hom Y), CategoryTheory.Grothendieck.comp X.id f = f |
_private.Init.Data.Nat.Lemmas.0.Nat.mul_eq_zero.match_1_1 | Init.Data.Nat.Lemmas | ∀ (n n_1 : ℕ) (motive : (n_1 + 1) * (n + 1) = 0 → Prop) (a : (n_1 + 1) * (n + 1) = 0), motive a |
Submonoid.map_inf_comap_of_surjective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {f : F},
Function.Surjective ⇑f → ∀ (S T : Submonoid N), Submonoid.map f (Submonoid.comap f S ⊓ Submonoid.comap f T) = S ⊓ T |
CStarModule.inner_zero_left | Mathlib.Analysis.CStarAlgebra.Module.Defs | ∀ {A : Type u_1} {E : Type u_2} [inst : NonUnitalRing A] [inst_1 : StarRing A] [inst_2 : AddCommGroup E]
[inst_3 : Module ℂ A] [inst_4 : Module ℂ E] [inst_5 : PartialOrder A] [inst_6 : SMul A E] [inst_7 : Norm A]
[inst_8 : Norm E] [inst_9 : CStarModule A E] [StarModule ℂ A] {x : E}, inner A 0 x = 0 |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getEntry_congr._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {a : α}
(h : Std.Internal.List.containsKey a l = true),
some (Std.Internal.List.getEntry a l h) = Std.Internal.List.getEntry? a l |
Lean.Grind.AC.Seq.collectVars._sunfold | Lean.Meta.Tactic.Grind.AC.VarRename | Lean.Grind.AC.Seq → Lean.Meta.Grind.VarCollector |
Matrix.kroneckerBilinear._proof_3 | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ {R : Type u_2} {α : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring α] [inst_2 : Algebra R α],
LinearMapClass (α →ₐ[R] Module.End R α) R α (Module.End R α) |
Int.fmod_eq_emod | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, a.fmod b = a % b + if 0 ≤ b ∨ b ∣ a then 0 else b |
_private.Init.Data.String.Basic.0.String.Pos.Raw.offsetOfPosAux._unary._proof_1 | Init.Data.String.Basic | ∀ (s : String) (i : String.Pos.Raw),
¬String.Pos.Raw.atEnd s i = true → s.utf8ByteSize - (String.Pos.Raw.next s i).byteIdx < s.utf8ByteSize - i.byteIdx |
ContinuousLinearEquiv.toLinearEquiv | Mathlib.Topology.Algebra.Module.Equiv | {R : Type u_1} →
{S : Type u_2} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
{σ : R →+* S} →
{σ' : S →+* R} →
[inst_2 : RingHomInvPair σ σ'] →
[inst_3 : RingHomInvPair σ' σ] →
{M : Type u_3} →
[inst_4 : TopologicalSpace M] →
[inst_5 : AddCommMonoid M] →
{M₂ : Type u_4} →
[inst_6 : TopologicalSpace M₂] →
[inst_7 : AddCommMonoid M₂] →
[inst_8 : Module R M] → [inst_9 : Module S M₂] → (M ≃SL[σ] M₂) → M ≃ₛₗ[σ] M₂ |
ProofWidgets.MarkdownDisplay.Props.mk | ProofWidgets.Component.Basic | String → ProofWidgets.MarkdownDisplay.Props |
Batteries.RBNode.Path.zoom_fill | Batteries.Data.RBMap.Alter | ∀ {α : Type u_1} {cut : α → Ordering} {t : Batteries.RBNode α} {path : Batteries.RBNode.Path α}
{t' : Batteries.RBNode α} {path' : Batteries.RBNode.Path α},
Batteries.RBNode.zoom cut t path = (t', path') → path.fill t = path'.fill t' |
CategoryTheory.Presieve.functorPushforward | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) → {X : C} → CategoryTheory.Presieve X → CategoryTheory.Presieve (F.obj X) |
SimplexCategory.Truncated.Hom.tr_id | Mathlib.AlgebraicTopology.SimplexCategory.Defs | ∀ {n : ℕ} (a : SimplexCategory) (ha : autoParam (a.len ≤ n) SimplexCategory.Truncated.Hom.tr_id._auto_1),
SimplexCategory.Truncated.Hom.tr (CategoryTheory.CategoryStruct.id a) ha ha =
CategoryTheory.CategoryStruct.id { obj := a, property := ha } |
ProbabilityTheory.Kernel.densityProcess_empty | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} [inst : MeasurableSpace.CountablyGenerated γ] (κ : ProbabilityTheory.Kernel α (γ × β))
(ν : ProbabilityTheory.Kernel α γ) (n : ℕ) (a : α) (x : γ), κ.densityProcess ν n a x ∅ = 0 |
Lean.Elab.FVarAliasInfo.mk | Lean.Elab.InfoTree.Types | Lean.Name → Lean.FVarId → Lean.FVarId → Lean.Elab.FVarAliasInfo |
Monotone.seq_pos_lt_seq_of_le_of_lt | Mathlib.Order.Iterate | ∀ {α : Type u_1} [inst : Preorder α] {f : α → α} {x y : ℕ → α},
Monotone f →
∀ {n : ℕ}, 0 < n → x 0 ≤ y 0 → (∀ k < n, x (k + 1) ≤ f (x k)) → (∀ k < n, f (y k) < y (k + 1)) → x n < y n |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.fmod_sub_cancel_left._simp_1_2 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, (b.fmod a = 0) = (a ∣ b) |
Mathlib.Tactic.BicategoryLike.Mor₂.whiskerLeft.inj | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | ∀ {e : Lean.Expr} {isoLift? : Option Mathlib.Tactic.BicategoryLike.IsoLift} {f g h : Mathlib.Tactic.BicategoryLike.Mor₁}
{η : Mathlib.Tactic.BicategoryLike.Mor₂} {e_1 : Lean.Expr} {isoLift?_1 : Option Mathlib.Tactic.BicategoryLike.IsoLift}
{f_1 g_1 h_1 : Mathlib.Tactic.BicategoryLike.Mor₁} {η_1 : Mathlib.Tactic.BicategoryLike.Mor₂},
Mathlib.Tactic.BicategoryLike.Mor₂.whiskerLeft e isoLift? f g h η =
Mathlib.Tactic.BicategoryLike.Mor₂.whiskerLeft e_1 isoLift?_1 f_1 g_1 h_1 η_1 →
e = e_1 ∧ isoLift? = isoLift?_1 ∧ f = f_1 ∧ g = g_1 ∧ h = h_1 ∧ η = η_1 |
Std.DHashMap.Internal.Raw₀.filterₘ | Std.Data.DHashMap.Internal.Model | {α : Type u} →
{β : α → Type v} → Std.DHashMap.Internal.Raw₀ α β → ((a : α) → β a → Bool) → Std.DHashMap.Internal.Raw₀ α β |
Lean.Elab.Tactic.TacticParsedSnapshot.toSnapshot | Lean.Elab.Term.TermElabM | Lean.Elab.Tactic.TacticParsedSnapshot → Lean.Language.Snapshot |
Lean.Lsp.InlayHintKind.casesOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.InlayHintKind → Sort u} →
(t : Lean.Lsp.InlayHintKind) → motive Lean.Lsp.InlayHintKind.type → motive Lean.Lsp.InlayHintKind.parameter → motive t |
Aesop.LocalRuleSet.forwardRulePatternSubstsInLocalDecl | Aesop.RuleSet | Aesop.LocalRuleSet → Lean.LocalDecl → Aesop.BaseM (Array (Aesop.ForwardRule × Aesop.Substitution)) |
RingHom.coe_inj | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} ⦃f g : α →+* β⦄, ⇑f = ⇑g → f = g |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0._regBuiltin.BitVec.reduceBitVecOfFin.declare_333._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.4171913895._hygCtx._hyg.13 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit |
OmegaCompletePartialOrder.Chain.ext | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} [inst : Preorder α] ⦃f g : OmegaCompletePartialOrder.Chain α⦄, ⇑f = ⇑g → f = g |
onePointEquivSphereOfFinrankEq._proof_5 | Mathlib.Topology.Compactification.OnePoint.Sphere | ∀ {ι : Type u_1} {V : Type u_2} [inst : Fintype ι] [inst_1 : AddCommGroup V] [inst_2 : Module ℝ V],
Module.finrank ℝ V + 1 = Fintype.card ι → Nonempty ι |
Int.strongRec.eq_1 | Mathlib.Data.Int.Basic | ∀ {m : ℤ} {motive : ℤ → Sort u_1} (lt : (n : ℤ) → n < m → motive n)
(ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → motive k) → motive n) (n : ℤ),
Int.strongRec lt ge n =
if hnm : n < m then lt n hnm
else
ge n ⋯
(Int.inductionOn' (motive := fun x => (k : ℤ) → k < x → motive k) n m lt
(fun _n a ih l a_1 => if hlm : l < m then lt l hlm else ge l ⋯ fun k x => ih k ⋯) fun n x hn l x_1 => hn l ⋯) |
CovBy | Mathlib.Order.Defs.PartialOrder | {α : Type u_2} → [LT α] → α → α → Prop |
CategoryTheory.PreOneHypercover.cylinderHomotopy._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} [inst_1 : CategoryTheory.Limits.HasPullbacks C] (f g : E.Hom F)
(p : (CategoryTheory.PreOneHypercover.cylinder f g).I₀),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.lift (f.h₀ p.fst) (g.h₀ p.fst) ⋯)
(F.toPullback p.snd))
(F.p₂ p.snd) =
((CategoryTheory.PreOneHypercover.cylinderHom f g).comp g).h₀ p |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_6} {B : Type u_3} {C : Type u_8} [inst : CategoryTheory.Category.{u_5, u_6} A]
[inst_1 : CategoryTheory.Category.{u_2, u_3} B] [inst_2 : CategoryTheory.Category.{u_7, u_8} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) {X : Type u_1} {Y : Type u_9}
[inst_3 : CategoryTheory.Category.{u_4, u_1} X] [inst_4 : CategoryTheory.Category.{u_10, u_9} Y]
{U V : CategoryTheory.Functor X Y} (α : U ⟶ V) (x : CategoryTheory.Limits.CategoricalPullback.CatCommSqOver F G Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.whiskerRight (CategoryTheory.Functor.whiskerRight α x.fst) F)
({
obj := fun S =>
{ fst := V.comp S.fst, snd := V.comp S.snd,
iso := V.associator S.fst F ≪≫ V.isoWhiskerLeft S.iso ≪≫ (V.associator S.snd G).symm },
map := fun {S S'} φ => { fst := V.whiskerLeft φ.fst, snd := V.whiskerLeft φ.snd, w := ⋯ }, map_id := ⋯,
map_comp := ⋯ }.obj
x).iso.hom =
CategoryTheory.CategoryStruct.comp
({
obj := fun S =>
{ fst := U.comp S.fst, snd := U.comp S.snd,
iso := U.associator S.fst F ≪≫ U.isoWhiskerLeft S.iso ≪≫ (U.associator S.snd G).symm },
map := fun {S S'} φ => { fst := U.whiskerLeft φ.fst, snd := U.whiskerLeft φ.snd, w := ⋯ }, map_id := ⋯,
map_comp := ⋯ }.obj
x).iso.hom
(CategoryTheory.Functor.whiskerRight (CategoryTheory.Functor.whiskerRight α x.snd) G) |
PreAbstractSimplicialComplex.map._proof_2 | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : DecidableEq β] (K : PreAbstractSimplicialComplex α) (f : α → β) {x : Finset β},
x ∈ (fun s => Finset.image f s) '' K.faces →
x.Nonempty ∧ ∀ ⦃b : Finset β⦄, b ≤ x → b.Nonempty → b ∈ (fun s => Finset.image f s) '' K.faces |
IntermediateField.intermediateFieldMap_apply_coe | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} {L' : Type u_3} [inst : Field K] [inst_1 : Field L] [inst_2 : Field L']
[inst_3 : Algebra K L] [inst_4 : Algebra K L'] (e : L ≃ₐ[K] L') (E : IntermediateField K L) (a : ↥E),
↑((IntermediateField.intermediateFieldMap e E) a) = e ↑a |
GradedObject.eulerChar_eq_sum_finSet_of_finrankSupport_subset | Mathlib.Algebra.Homology.EulerCharacteristic | ∀ {R : Type u_1} [inst : Ring R] {ι : Type u_2} (c : ComplexShape ι) [inst_1 : c.EulerCharSigns]
(X : CategoryTheory.GradedObject ι (ModuleCat R)) (indices : Finset ι),
GradedObject.finrankSupport X ⊆ ↑indices →
GradedObject.eulerChar c X = ∑ i ∈ indices, ↑(c.χ i) * ↑(Module.finrank R ↑(X i)) |
Cardinal.powerlt_mono_left | Mathlib.SetTheory.Cardinal.Basic | ∀ (a : Cardinal.{u_1}), Monotone fun c => a ^< c |
Lean.Expr.FindStep.done | Lean.Util.FindExpr | Lean.Expr.FindStep |
AlgebraicGeometry.Scheme.irreducibleComponentOpen._proof_1 | Mathlib.AlgebraicGeometry.IdealSheaf.IrreducibleComponent | ∀ (X : AlgebraicGeometry.Scheme) (Z : Set ↥X) [AlgebraicGeometry.IsNoetherian X],
IsOpen (⋃₀ (irreducibleComponents ↥X \ {Z}))ᶜ |
midpoint_eq_midpoint_iff_vsub_eq_vsub | Mathlib.LinearAlgebra.AffineSpace.Midpoint | ∀ (R : Type u_1) {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] {x x' y y' : P}, midpoint R x y = midpoint R x' y' ↔ x -ᵥ x' = y' -ᵥ y |
CategoryTheory.Limits.MultispanShape.ctorIdx | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | CategoryTheory.Limits.MultispanShape → ℕ |
_private.Mathlib.Data.Int.CardIntervalMod.0.Nat.Ico_filter_modEq_cast._simp_1_4 | Mathlib.Data.Int.CardIntervalMod | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ |
IsLowerSet.vadd | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α] {s : Set α} {a : α},
IsLowerSet s → IsLowerSet (a +ᵥ s) |
PrimeSpectrum.noConfusion | Mathlib.RingTheory.Spectrum.Prime.Defs | {P : Sort u} →
{R : Type u_1} →
{inst : CommSemiring R} →
{t : PrimeSpectrum R} →
{R' : Type u_1} →
{inst' : CommSemiring R'} →
{t' : PrimeSpectrum R'} → R = R' → inst ≍ inst' → t ≍ t' → PrimeSpectrum.noConfusionType P t t' |
CategoryTheory.ObjectProperty.shiftClosure_le_iff | Mathlib.CategoryTheory.ObjectProperty.Shift | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P Q : CategoryTheory.ObjectProperty C) {A : Type u_2}
[inst_1 : AddMonoid A] [inst_2 : CategoryTheory.HasShift C A] [Q.IsClosedUnderIsomorphisms] [Q.IsStableUnderShift A],
P.shiftClosure A ≤ Q ↔ P ≤ Q |
_private.Mathlib.Analysis.InnerProductSpace.Positive.0.ContinuousLinearMap.isPositive_iff_eq_sum_rankOne._simp_1_4 | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {K : Type u_1} [inst : RCLike K] (r s : ℝ), ↑r * ↑s = ↑(r * s) |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.MessageOverview.rpcRequest.elim | Lean.Server.ProtocolOverview | {motive : Lean.Server.Overview.MessageOverview✝ → Sort u} →
(t : Lean.Server.Overview.MessageOverview✝¹) →
Lean.Server.Overview.MessageOverview.ctorIdx✝ t = 1 →
((o : Lean.Server.Overview.RpcRequestOverview✝) → motive (Lean.Server.Overview.MessageOverview.rpcRequest✝ o)) →
motive t |
Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateRight._proof_12 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight | ∀ {w : ℕ}, 0 ≤ w |
CategoryTheory.Limits.HasCokernels.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C],
autoParam (∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.Limits.HasCokernel f)
CategoryTheory.Limits.HasCokernels.has_colimit._autoParam →
CategoryTheory.Limits.HasCokernels C |
_private.Mathlib.NumberTheory.Padics.MahlerBasis.0.PadicInt.mahlerSeries_apply_nat._proof_1_1 | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {m n : ℕ}, m ≤ n → ∀ (i : ℕ), m < i + (n + 1) |
Lean.Meta.RefinedDiscrTree.Trie.node._flat_ctor | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | {α : Type} →
Array α →
Option Lean.Meta.RefinedDiscrTree.TrieIndex →
Std.HashMap ℕ Lean.Meta.RefinedDiscrTree.TrieIndex →
Std.HashMap Lean.Meta.RefinedDiscrTree.Key Lean.Meta.RefinedDiscrTree.TrieIndex →
Array (Lean.Meta.RefinedDiscrTree.LazyEntry × α) → Lean.Meta.RefinedDiscrTree.Trie α |
Lean.Lsp.WorkspaceSymbolParams.noConfusionType | Lean.Data.Lsp.LanguageFeatures | Sort u → Lean.Lsp.WorkspaceSymbolParams → Lean.Lsp.WorkspaceSymbolParams → Sort u |
NumberField.mixedEmbedding.fundamentalCone.realSpaceToLogSpace._proof_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x x_1 : NumberField.mixedEmbedding.realSpace K),
(fun w => (x + x_1) ↑w - (↑(↑w).mult * ∑ w', (x + x_1) w') * (↑(Module.finrank ℚ K))⁻¹) =
(fun w => x ↑w - (↑(↑w).mult * ∑ w', x w') * (↑(Module.finrank ℚ K))⁻¹) + fun w =>
x_1 ↑w - (↑(↑w).mult * ∑ w', x_1 w') * (↑(Module.finrank ℚ K))⁻¹ |
Int.lcm_mul_right_right | Init.Data.Int.Gcd | ∀ (a b : ℤ), a.lcm (a * b) = a.natAbs * b.natAbs |
qExpansionRingHom | Mathlib.NumberTheory.ModularForms.QExpansion | {Γ : Subgroup (GL (Fin 2) ℝ)} →
(h : ℝ) →
[inst : Γ.HasDetPlusMinusOne] →
0 < h → h ∈ Γ.strictPeriods → (DirectSum ℤ fun k => ModularForm Γ k) →+* PowerSeries ℂ |
UInt32.lt_add_one | Init.Data.UInt.Lemmas | ∀ {c : UInt32}, c ≠ -1 → c < c + 1 |
PrimeMultiset.prod | Mathlib.Data.PNat.Factors | PrimeMultiset → ℕ+ |
String.Slice.Pattern.ToForwardSearcher.mk | Init.Data.String.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
{σ : outParam (String.Slice → Type)} →
((s : String.Slice) → Std.Iter (String.Slice.Pattern.SearchStep s)) → String.Slice.Pattern.ToForwardSearcher pat σ |
UpperHalfPlane.num._proof_1 | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | NeZero (1 + 1) |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.getEqIffEnumToBitVecEqFor | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | Lean.Name → Lean.MetaM Lean.Name |
IntermediateField.isSeparable_of_mem_isSeparable | Mathlib.FieldTheory.SeparableDegree | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {L : IntermediateField F E}
[Algebra.IsSeparable F ↥L] {x : E}, x ∈ L → IsSeparable F x |
RootPairing.nsmul_notMem_range_root | Mathlib.LinearAlgebra.RootSystem.Reduced | ∀ {ι : 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] (P : RootPairing ι R M N) [CharZero R]
[IsAddTorsionFree M] [P.IsReduced] {n : ℕ} [n.AtLeastTwo] {i : ι}, n • P.root i ∉ Set.range ⇑P.root |
Aesop.GoalId.casesOn | Aesop.Tree.Data | {motive : Aesop.GoalId → Sort u} → (t : Aesop.GoalId) → ((toNat : ℕ) → motive { toNat := toNat }) → motive t |
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.toOplax | Mathlib.CategoryTheory.Bicategory.Monad.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat B →
CategoryTheory.OplaxFunctor (CategoryTheory.LocallyDiscrete (CategoryTheory.Discrete PUnit.{1})) B |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.isCongruent.goEq | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.ENodeMap → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Bool |
_private.Lean.Data.Lsp.Internal.0.Lean.Lsp.instBEqRefIdent.beq.match_1 | Lean.Data.Lsp.Internal | (motive : Lean.Lsp.RefIdent → Lean.Lsp.RefIdent → Sort u_1) →
(x x_1 : Lean.Lsp.RefIdent) →
((a a_1 b b_1 : String) → motive (Lean.Lsp.RefIdent.const a a_1) (Lean.Lsp.RefIdent.const b b_1)) →
((a a_1 b b_1 : String) → motive (Lean.Lsp.RefIdent.fvar a a_1) (Lean.Lsp.RefIdent.fvar b b_1)) →
((x x_2 : Lean.Lsp.RefIdent) → motive x x_2) → motive x x_1 |
Unitization.inrNonUnitalAlgHom._proof_1 | Mathlib.Algebra.Algebra.Unitization | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A] (r : R)
(m : A), ↑(r • m) = r • ↑m |
_private.Lean.Meta.LitValues.0.Lean.Meta.normLitValue.match_13 | Lean.Meta.LitValues | (motive : Option UInt16 → Sort u_1) →
(__do_lift : Option UInt16) → ((n : UInt16) → motive (some n)) → ((x : Option UInt16) → motive x) → motive __do_lift |
_private.Init.Data.Int.Order.0.Int.toNat_sub''.match_1_1 | Init.Data.Int.Order | ∀ (motive : (a b : ℤ) → (∃ n, a = ↑n) → (∃ n, b = ↑n) → 0 ≤ a → 0 ≤ b → Prop) (a b : ℤ) (x : ∃ n, a = ↑n)
(x_1 : ∃ n, b = ↑n) (ha : 0 ≤ a) (hb : 0 ≤ b),
(∀ (w w_1 : ℕ) (ha : 0 ≤ ↑w) (hb : 0 ≤ ↑w_1), motive ↑w ↑w_1 ⋯ ⋯ ha hb) → motive a b x x_1 ha hb |
_private.Std.Data.DTreeMap.Internal.Operations.0.PSigma.casesOn._arg_pusher | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → rel t y → β_1 y) → motive t) t mk fun y h => f y) =
PSigma.casesOn t fun fst snd => mk fst snd fun y h => f y |
_private.Mathlib.RingTheory.Flat.Basic.0.Module.Flat.directSum_iff._simp_1_3 | Mathlib.RingTheory.Flat.Basic | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ : Module R₃ M₃}
{σ₁₂ : R₁ →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_6 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] (f : M₂ →ₛₗ[σ₂₃] M₃)
(g : M₁ →ₛₗ[σ₁₂] M₂), ⇑f ∘ ⇑g = ⇑(f ∘ₛₗ g) |
Std.DHashMap.Internal.Raw₀.Const.insertMany_nil | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β),
↑(Std.DHashMap.Internal.Raw₀.Const.insertMany m []) = m |
List.dropLast_append_cons | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l₁ : List α} {b : α} {l₂ : List α}, (l₁ ++ b :: l₂).dropLast = l₁ ++ (b :: l₂).dropLast |
Subarray.scanlM.eq_1 | Batteries.Data.Array.Scan | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} [inst : Monad m] (f : β → α → m β) (init : β)
(as : Subarray α), Subarray.scanlM f init as = Array.scanlM f init as.array as.start as.stop |
MeasureTheory.Measure.sum_fintype | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_5} {m0 : MeasurableSpace α} [inst : Fintype ι] (μ : ι → MeasureTheory.Measure α),
MeasureTheory.Measure.sum μ = ∑ i, μ i |
LightCondensed.instMonoidalClosedFunctorOppositeLightProfiniteModuleCat._proof_1 | Mathlib.Condensed.Light.Monoidal | ∀ (R : Type u_1) [inst : CommRing R], (CategoryTheory.equivSmallModel LightProfinite).op.congrLeft.functor.IsEquivalence |
Finset.preimage_add_right_zero' | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : AddGroup α] {b : α}, Finset.preimage 0 (fun x => x + -b) ⋯ = {b} |
FreeAddMagma.add | Mathlib.Algebra.Free | {α : Type u} → FreeAddMagma α → FreeAddMagma α → FreeAddMagma α |
Lean.Meta.FindSplitImpl.Context.recOn | Lean.Meta.Tactic.SplitIf | {motive : Lean.Meta.FindSplitImpl.Context → Sort u} →
(t : Lean.Meta.FindSplitImpl.Context) →
((exceptionSet : Lean.ExprSet) →
(kind : Lean.Meta.SplitKind) → motive { exceptionSet := exceptionSet, kind := kind }) →
motive t |
Lean.Lsp.FoldingRange.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{startLine endLine : ℕ} →
{kind? : Option Lean.Lsp.FoldingRangeKind} →
{startLine' endLine' : ℕ} →
{kind?' : Option Lean.Lsp.FoldingRangeKind} →
{ startLine := startLine, endLine := endLine, kind? := kind? } =
{ startLine := startLine', endLine := endLine', kind? := kind?' } →
(startLine = startLine' → endLine = endLine' → kind? = kind?' → P) → P |
Lean.Meta.AC.PreExpr.brecOn.go | Lean.Meta.Tactic.AC.Main | {motive : Lean.Meta.AC.PreExpr → Sort u} →
(t : Lean.Meta.AC.PreExpr) →
((t : Lean.Meta.AC.PreExpr) → Lean.Meta.AC.PreExpr.below t → motive t) → motive t ×' Lean.Meta.AC.PreExpr.below t |
Set.opEquiv_self | Mathlib.Data.Set.Opposite | {α : Type u_1} → (s : Set α) → ↑s.op ≃ ↑s |
Complex.sin_surjective | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | Function.Surjective Complex.sin |
Module.FinitePresentation.linearEquivMap._proof_3 | Mathlib.Algebra.Module.FinitePresentation | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R R R |
Order.Icc_subset_Ico_succ_right._simp_1 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] [NoMaxOrder α] (a b : α),
(Set.Icc a b ⊆ Set.Ico a (Order.succ b)) = True |
Algebra.IsAlgebraic.algHomEquivAlgHomOfSplits._proof_1 | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ (A : Type u_1) [Field A], Nontrivial A |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_560 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α)
(h :
List.idxOfNth w [g (g a)] {g a, g (g a)}.card + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length),
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w [g (g a)] {g a, g (g a)}.card] <
[g a, g (g a)].length |
AddCon.ker.congr_simp | Mathlib.Algebra.Colimit.Module | ∀ {M : Type u_1} {N : Type u_2} {F : Type u_4} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[inst_3 : AddHomClass F M N] (f f_1 : F), f = f_1 → AddCon.ker f = AddCon.ker f_1 |
CategoryTheory.Functor.chosenProd.fst | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
[self : CategoryTheory.SemiCartesianMonoidalCategory C] →
(X Y : C) → CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ⟶ X |
FinBoolAlg.hasForgetToFinBddDistLat._proof_4 | Mathlib.Order.Category.FinBoolAlg | { obj := fun X => FinBddDistLat.of ↑X.toBoolAlg, map := fun {X Y} f => FinBddDistLat.ofHom (BoolAlg.Hom.hom f.hom),
map_id := FinBoolAlg.hasForgetToFinBddDistLat._proof_1,
map_comp := @FinBoolAlg.hasForgetToFinBddDistLat._proof_2 }.comp
(CategoryTheory.forget FinBddDistLat) =
CategoryTheory.forget FinBoolAlg |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.image_sub_const_Ico._proof_1_3 | Mathlib.Order.Interval.Finset.Nat | ∀ {a b c : ℕ} (x : ℕ), a - c ≤ x ∧ x < b - c → (a ≤ x + c ∧ x + c < b) ∧ x + c - c = x |
ENNReal.add_halves | Mathlib.Data.ENNReal.Inv | ∀ (a : ENNReal), a / 2 + a / 2 = a |
Finset.map_insert | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq α] [inst_1 : DecidableEq β] (f : α ↪ β) (a : α) (s : Finset α),
Finset.map f (insert a s) = insert (f a) (Finset.map f s) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.