name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Set.Iio_subset_Iic_self | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, Set.Iio a ⊆ Set.Iic a |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.VarStateM.computeCoefficients | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Op →
Lean.Expr →
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.VarStateM Lean.Elab.Tactic.BVDecide.Frontend.Normalize.CoefficientsMap |
Real.binEntropy_eq_negMulLog_add_negMulLog_one_sub | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ (p : ℝ), Real.binEntropy p = p.negMulLog + (1 - p).negMulLog |
_private.Lean.Elab.BuiltinDo.MatchExpr.0.Lean.Elab.Do.elabDoMatchExpr.elabDoMatchExprNoMeta.elabMatch._unary._proof_3 | Lean.Elab.BuiltinDo.MatchExpr | ∀ (alts : Lean.TSyntax `Lean.Parser.Term.matchExprAlts), True |
RelSeries.coe_ofLE | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (x : RelSeries r) {s : SetRel α α} (h : r ≤ s), (x.ofLE h).toFun = x.toFun |
Equiv.Perm.Disjoint.cycleOf_mul_distrib | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_2} {f g : Equiv.Perm α} [inst : DecidableRel f.SameCycle] [inst_1 : DecidableRel g.SameCycle]
[inst_2 : DecidableRel (f * g).SameCycle], f.Disjoint g → ∀ (x : α), (f * g).cycleOf x = f.cycleOf x * g.cycleOf x |
Function.support_binop_subset | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} {P : Type u_5} [inst : Zero M] [inst_1 : Zero N] [inst_2 : Zero P]
(op : M → N → P),
op 0 0 = 0 →
∀ (f : ι → M) (g : ι → N), (Function.support fun x => op (f x) (g x)) ⊆ Function.support f ∪ Function.support g |
Turing.PartrecToTM2.instDecidableEqCont'.decEq._proof_30 | Mathlib.Computability.TMToPartrec | ∀ (a : Turing.ToPartrec.Code) (a_1 : Turing.PartrecToTM2.Cont'),
Turing.PartrecToTM2.Cont'.comp a a_1 = Turing.PartrecToTM2.Cont'.comp a a_1 |
LinearMap.mulLeft_one | Mathlib.Algebra.Module.LinearMap.Basic | ∀ (R : Type u_6) (A : Type u_7) [inst : Semiring R] [inst_1 : NonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : SMulCommClass R A A], LinearMap.mulLeft R 1 = LinearMap.id |
CategoryTheory.instIsEquivalenceOppositeUnopUnop | Mathlib.CategoryTheory.Opposites | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C], (CategoryTheory.unopUnop C).IsEquivalence |
_private.Mathlib.CategoryTheory.Triangulated.Yoneda.0.CategoryTheory.Pretriangulated.preadditiveCoyoneda_homologySequenceδ_apply._proof_1 | Mathlib.CategoryTheory.Triangulated.Yoneda | ∀ (n₀ n₁ : ℤ), n₀ + 1 = n₁ → 1 + n₀ = n₁ |
CategoryTheory.Limits.coequalizer.isoTargetOfSelf | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → {X Y : C} → (f : X ⟶ Y) → CategoryTheory.Limits.coequalizer f f ≅ Y |
IsOrderConnected.casesOn | Mathlib.Order.RelClasses | {α : Type u} →
{lt : α → α → Prop} →
{motive : IsOrderConnected α lt → Sort u_1} →
(t : IsOrderConnected α lt) → ((conn : ∀ (a b c : α), lt a c → lt a b ∨ lt b c) → motive ⋯) → motive t |
Lean.Elab.Tactic.RCases.RCasesPatt.explicit.noConfusion | Lean.Elab.Tactic.RCases | {P : Sort u} →
{ref : Lean.Syntax} →
{a : Lean.Elab.Tactic.RCases.RCasesPatt} →
{ref' : Lean.Syntax} →
{a' : Lean.Elab.Tactic.RCases.RCasesPatt} →
Lean.Elab.Tactic.RCases.RCasesPatt.explicit ref a = Lean.Elab.Tactic.RCases.RCasesPatt.explicit ref' a' →
(ref = ref' → a = a' → P) → P |
AddSubgroup.mem_inertia | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {M : Type u_6} [inst : AddGroup M] {I : AddSubgroup M} {G : Type u_7} [inst_1 : Group G] [inst_2 : MulAction G M]
{σ : G}, σ ∈ I.inertia G ↔ ∀ (x : M), σ • x - x ∈ I |
Heyting.Regular.gi._proof_3 | Mathlib.Order.Heyting.Regular | ∀ {α : Type u_1} [inst : HeytingAlgebra α] (x : Heyting.Regular α), ↑x ≤ (↑x)ᶜᶜ |
CategoryTheory.Functor.instFaithfulProdCurry | Mathlib.CategoryTheory.Functor.Currying | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} D]
{E : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} E], CategoryTheory.Functor.curry.Faithful |
Lean.Lsp.instToJsonSignatureHelpOptions.toJson | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SignatureHelpOptions → Lean.Json |
SimpleGraph.Walk.exists_length_eq_zero_iff._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walks.Basic | ∀ {V : Type u} {G : SimpleGraph V} {u v : V}, (∃ p, p.length = 0) = (u = v) |
MeasureTheory.FiniteMeasure.continuous_iff_forall_continuousMap_continuous_integral | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
{X : Type u_2} [inst_3 : TopologicalSpace X] {μs : X → MeasureTheory.FiniteMeasure Ω} [CompactSpace Ω],
Continuous μs ↔ ∀ (f : C(Ω, ℝ)), Continuous fun x => ∫ (ω : Ω), f ω ∂↑(μs x) |
SeparationQuotient.instNonAssocRing._proof_8 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : NonAssocRing R], SeparationQuotient.mk 1 = 1 |
normHom._proof_1 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [inst : SeminormedRing α], ‖0‖ = 0 |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.Subgraph.subgraphOfAdj_eq_induce._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {α : Type u} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) |
SimpleGraph.turanGraph._proof_2 | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ (n r : ℕ), Symmetric fun v w => ↑v % r ≠ ↑w % r |
LinearMap.BilinForm.toMatrixAux.eq_1 | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R₁] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R₁ M₁]
{n : Type u_5} (b : n → M₁), LinearMap.BilinForm.toMatrixAux b = LinearMap.toMatrix₂Aux R₁ b b |
CategoryTheory.Functor.FullyFaithful.mapCommGrp._proof_4 | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u_4} [inst_3 : CategoryTheory.Category.{u_3, u_4} D]
[inst_4 : CategoryTheory.CartesianMonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
{F : CategoryTheory.Functor C D} [inst_6 : F.Braided] (hF : F.FullyFaithful) {X Y : CategoryTheory.CommGrp C}
(f : X ⟶ Y),
CategoryTheory.InducedCategory.homMk (CategoryTheory.Grp.homMk' (hF.mapMon.preimage (F.mapCommGrp.map f).hom.hom)) = f |
FreeGroup.instOne | Mathlib.GroupTheory.FreeGroup.Basic | {α : Type u} → One (FreeGroup α) |
AddGroupNorm.toAddGroupSeminorm | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} → [inst : AddGroup G] → AddGroupNorm G → AddGroupSeminorm G |
QuadraticMap.toBilinHom._proof_2 | Mathlib.LinearAlgebra.QuadraticForm.Basis | ∀ {R : Type u_1} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup N] [inst_2 : Module R N] (S : Type u_2)
[inst_3 : CommSemiring S] [inst_4 : Algebra S R] [inst_5 : Module S N] [IsScalarTower S R N], SMulCommClass R S N |
_private.Mathlib.Combinatorics.Nullstellensatz.0.MvPolynomial.Alon.of_mem_P_support._simp_1_2 | Mathlib.Combinatorics.Nullstellensatz | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b |
mfderivWithin_id | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : 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] {s : Set M} {x : M},
UniqueMDiffWithinAt I s x → mfderivWithin I I id s x = ContinuousLinearMap.id 𝕜 (TangentSpace I x) |
Subgroup.isComplement_iff_existsUnique_mul_inv_mem | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : Group G] {S T : Set G}, Subgroup.IsComplement S T ↔ ∀ (g : G), ∃! t, g * (↑t)⁻¹ ∈ S |
_private.Lean.Compiler.LCNF.Simp.Main.0.Lean.Compiler.LCNF.Simp.inlineApp?.match_1 | Lean.Compiler.LCNF.Simp.Main | (motive : Option Lean.Compiler.LCNF.Simp.InlineCandidateInfo → Sort u_1) →
(__discr : Option Lean.Compiler.LCNF.Simp.InlineCandidateInfo) →
((info : Lean.Compiler.LCNF.Simp.InlineCandidateInfo) → motive (some info)) →
((x : Option Lean.Compiler.LCNF.Simp.InlineCandidateInfo) → motive x) → motive __discr |
Lean.Grind.Linarith.instBEqPoly.beq | Init.Grind.Ordered.Linarith | Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Poly → Bool |
catalan_succ | Mathlib.Combinatorics.Enumerative.Catalan | ∀ (n : ℕ), catalan (n + 1) = ∑ i, catalan ↑i * catalan (n - ↑i) |
Lean.Lsp.InlayHintTooltip.recOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.InlayHintTooltip → Sort u} →
(t : Lean.Lsp.InlayHintTooltip) →
((text : String) → motive (Lean.Lsp.InlayHintTooltip.plaintext text)) →
((markup : Lean.Lsp.MarkupContent) → motive (Lean.Lsp.InlayHintTooltip.markdown markup)) → motive t |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.Z | Mathlib.CategoryTheory.MorphismProperty.Factorization | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W₁ W₂ : CategoryTheory.MorphismProperty C} →
W₁.FunctorialFactorizationData W₂ → CategoryTheory.Functor (CategoryTheory.Arrow C) C |
LinearMap.finite_iff_of_bijective | Mathlib.RingTheory.Finiteness.Basic | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {S : Type u_7}
{P : Type u_6} [inst_3 : Semiring S] [inst_4 : AddCommMonoid P] [inst_5 : Module S P] {σ : R →+* S}
[RingHomSurjective σ] (f : M →ₛₗ[σ] P), Function.Bijective ⇑f → (Module.Finite R M ↔ Module.Finite S P) |
ContinuousLinearEquiv.toContinuousAffineEquiv_toContinuousAffineMap | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ {k : Type u_1} [inst : Ring k] {E : Type u_10} {F : Type u_11} [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), L.toContinuousAffineEquiv.toContinuousAffineMap = (↑L).toContinuousAffineMap |
_private.Lean.Util.HasConstCache.0.Lean.HasConstCache.containsUnsafe.match_1 | Lean.Util.HasConstCache | {declNames : Array Lean.Name} →
(motive : Lean.HasConstCache declNames → Sort u_1) →
(x : Lean.HasConstCache declNames) →
((cache : Std.HashMap.Raw Lean.Expr Bool) → motive { cache := cache }) → motive x |
_private.Lean.Meta.Eqns.0.Lean.Meta.shouldGenerateEqnThms.match_1 | Lean.Meta.Eqns | (motive : Option Lean.AsyncConstantInfo → Sort u_1) →
(x : Option Lean.AsyncConstantInfo) →
((name : Lean.Name) →
(sig : Task Lean.ConstantVal) →
(constInfo : Task Lean.ConstantInfo) →
motive (some { name := name, kind := Lean.ConstantKind.defn, sig := sig, constInfo := constInfo })) →
((x : Option Lean.AsyncConstantInfo) → motive x) → motive x |
_private.Std.Sat.AIG.CachedGatesLemmas.0.Std.Sat.AIG.imp_as_aig | Std.Sat.AIG.CachedGatesLemmas | ∀ (a b : Bool), (!(a && !b)) = (!a || b) |
LieIdeal.incl_injective | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L),
Function.Injective ⇑I.incl |
CategoryTheory.Functor.Fiber.instIsHomLiftIdMapFiberInclusion | Mathlib.CategoryTheory.FiberedCategory.Fiber | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} {S : 𝒮} {a b : p.Fiber S} (φ : a ⟶ b),
p.IsHomLift (CategoryTheory.CategoryStruct.id S) (CategoryTheory.Functor.Fiber.fiberInclusion.map φ) |
Lean.Macro.Context.recOn | Init.Prelude | {motive : Lean.Macro.Context → Sort u} →
(t : Lean.Macro.Context) →
((methods : Lean.Macro.MethodsRef) →
(quotContext : Lean.Name) →
(currMacroScope : Lean.MacroScope) →
(currRecDepth maxRecDepth : ℕ) →
(ref : Lean.Syntax) →
motive
{ methods := methods, quotContext := quotContext, currMacroScope := currMacroScope,
currRecDepth := currRecDepth, maxRecDepth := maxRecDepth, ref := ref }) →
motive t |
Lean.Elab.Tactic.Do.ProofMode.parseHyp? | Lean.Elab.Tactic.Do.ProofMode.MGoal | Lean.Expr → Option Lean.Elab.Tactic.Do.ProofMode.Hyp |
NumberField.instIsLocalizedModuleIntSubtypeMemSubmoduleRingOfIntegersCoeToSubmoduleValFractionalIdealNonZeroDivisorsRestrictScalarsSubtype | Mathlib.NumberTheory.NumberField.FractionalIdeal | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ),
IsLocalizedModule (nonZeroDivisors ℤ) (↑ℤ (↑↑I).subtype) |
CauchySeq.add_const | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Type u_3}
[inst_3 : Preorder ι] {u : ι → α} {x : α}, CauchySeq u → CauchySeq fun n => u n + x |
Plausible.Random | Plausible.Random | (Type u → Type u_1) → Type u → Type (max (max 1 u) u_1) |
TensorProduct.mapOfCompatibleSMul._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ (R : Type u_3) [inst : CommSemiring R] (A : Type u_4) (M : Type u_1) (N : Type u_2) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] [inst_5 : CommSemiring A] [inst_6 : Module A M]
[inst_7 : Module A N] [inst_8 : SMulCommClass R A M] [inst_9 : TensorProduct.CompatibleSMul R A M N] (x x_1 : M)
(x_2 : N),
(let __spread.0 := (TensorProduct.mk R M N) (x + x_1);
{ toAddHom := __spread.0.toAddHom, map_smul' := ⋯ })
x_2 =
((let __spread.0 := (TensorProduct.mk R M N) x;
{ toAddHom := __spread.0.toAddHom, map_smul' := ⋯ }) +
let __spread.0 := (TensorProduct.mk R M N) x_1;
{ toAddHom := __spread.0.toAddHom, map_smul' := ⋯ })
x_2 |
AnalyticAt.analyticWithinAt | Mathlib.Analysis.Analytic.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F} {s : Set E} {x : E},
AnalyticAt 𝕜 f x → AnalyticWithinAt 𝕜 f s x |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.sup | Mathlib.CategoryTheory.Presentable.Directed | {J : Type w} →
[inst : CategoryTheory.SmallCategory J] →
{κ : Cardinal.{w}} →
[Fact κ.IsRegular] →
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ →
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ →
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ |
Mathlib.Meta.FunProp.initFn._@.Mathlib.Tactic.FunProp.Theorems.2854048689._hygCtx._hyg.2 | Mathlib.Tactic.FunProp.Theorems | IO Mathlib.Meta.FunProp.LambdaTheoremsExt |
Ordnode.eraseMax.valid | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u_1} [inst : Preorder α] {t : Ordnode α}, t.Valid → t.eraseMax.Valid |
Module.End.hasEigenvalue_of_isRoot | Mathlib.LinearAlgebra.Eigenspace.Minpoly | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R} [IsDomain R] [Module.Finite R M], (minpoly R f).IsRoot μ → f.HasEigenvalue μ |
continuousOn_cfcₙ_nnreal_setProd | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | ∀ {A : Type u_2} [inst : NonUnitalNormedRing A] [inst_1 : StarRing A] [inst_2 : NormedSpace ℝ A]
[inst_3 : IsScalarTower ℝ A A] [inst_4 : SMulCommClass ℝ A A] [ContinuousStar A]
[inst_6 : NonUnitalIsometricContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_7 : PartialOrder A]
[inst_8 : StarOrderedRing A] [inst_9 : NonnegSpectrumClass ℝ A] [T2Space A] [IsTopologicalRing A] {s : Set NNReal},
IsCompact s →
ContinuousOn (fun fa => cfcₙ ((UniformOnFun.toFun {s}) fa.1) fa.2)
({f | ContinuousOn ((UniformOnFun.toFun {s}) f) s ∧ f 0 = 0} ×ˢ {a | 0 ≤ a ∧ quasispectrum NNReal a ⊆ s}) |
CategoryTheory.Pseudofunctor.map₂_left_unitor_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(self : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a ⟶ b) {Z : self.obj a ⟶ self.obj b} (h : self.map f ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map₂ (CategoryTheory.Bicategory.leftUnitor f).hom) h =
CategoryTheory.CategoryStruct.comp (self.mapComp (CategoryTheory.CategoryStruct.id a) f).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (self.mapId a).hom (self.map f))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor (self.map f)).hom h)) |
FractionalIdeal.right_inverse_eq | Mathlib.RingTheory.FractionalIdeal.Inverse | ∀ (K : Type u_3) [inst : Field K] {R₁ : Type u_4} [inst_1 : CommRing R₁] [inst_2 : IsDomain R₁] [inst_3 : Algebra R₁ K]
[inst_4 : IsFractionRing R₁ K] (I J : FractionalIdeal (nonZeroDivisors R₁) K), I * J = 1 → J = I⁻¹ |
Lean.Elab.Term.elabNamedPattern | Lean.Elab.App | Lean.Elab.Term.TermElab |
CategoryTheory.Limits.IsInitial.ofBinaryCoproductDisjointOfIsColimitOfIsLimit._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.DisjointCoproduct | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X Y : C}
[CategoryTheory.Limits.BinaryCoproductDisjoint X Y] {c : CategoryTheory.Limits.BinaryCofan X Y}
(hc : CategoryTheory.Limits.IsColimit c) {s : CategoryTheory.Limits.PullbackCone c.inl c.inr}
(hs : CategoryTheory.Limits.IsLimit s), Nonempty (CategoryTheory.Limits.IsInitial s.pt) |
CategoryTheory.heq_eqToHom_comp_iff._simp_1 | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W X Y Z Z' : C} (f : Y ⟶ X) (g : Z ⟶ Z') (h : W = Y),
(g ≍ CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom h) f) = (g ≍ f) |
ContinuousCohomology.kerHomogeneousCochainsZeroEquiv._proof_16 | Mathlib.Algebra.Category.ContinuousCohomology.Basic | ∀ (R : Type u_3) (G : Type u_1) [inst : CommRing R] [inst_1 : Group G] [inst_2 : TopologicalSpace R]
[inst_3 : TopologicalSpace G] [inst_4 : IsTopologicalGroup G] (X : Action (TopModuleCat R) G) (n : ℕ),
n = 1 →
∀ (x : ↑((ContinuousCohomology.invariants R G).obj X).toModuleCat),
⟨(ContinuousLinearMap.const R G) ↑x, ⋯⟩ ∈
(↑(TopModuleCat.Hom.hom (((ContinuousCohomology.homogeneousCochains R G).obj X).d 0 n))).ker |
CategoryTheory.Limits.IsColimit.pushoutCoconeEquivBinaryCofanInverse._proof_2 | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
{c : CategoryTheory.Limits.BinaryCofan (CategoryTheory.Under.mk f) (CategoryTheory.Under.mk g)}
(hc : CategoryTheory.Limits.IsColimit c)
(s :
CategoryTheory.Limits.PushoutCocone
((CategoryTheory.Limits.pair (CategoryTheory.Under.mk f) (CategoryTheory.Under.mk g)).obj
{ as := CategoryTheory.Limits.WalkingPair.left }).hom
((CategoryTheory.Limits.pair (CategoryTheory.Under.mk f) (CategoryTheory.Under.mk g)).obj
{ as := CategoryTheory.Limits.WalkingPair.right }).hom),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id C).map c.inr.right)
((fun s => (hc.desc (CategoryTheory.Limits.pushoutCoconeEquivBinaryCofan.functor.obj s)).right) s) =
s.inr |
initFn._@.Mathlib.Tactic.ContinuousFunctionalCalculus.2038506681._hygCtx._hyg.3 | Mathlib.Tactic.ContinuousFunctionalCalculus | IO Unit |
DFinsupp.isScalarTower | Mathlib.Data.DFinsupp.Module | ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} {δ : Type u_1} [inst : (i : ι) → Zero (β i)]
[inst_1 : (i : ι) → SMulZeroClass γ (β i)] [inst_2 : (i : ι) → SMulZeroClass δ (β i)] [inst_3 : SMul γ δ]
[∀ (i : ι), IsScalarTower γ δ (β i)], IsScalarTower γ δ (Π₀ (i : ι), β i) |
MeasureTheory.Submartingale.stoppedValue_leastGE | Mathlib.Probability.Martingale.BorelCantelli | ∀ {Ω : Type u_2} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {ℱ : MeasureTheory.Filtration ℕ m0}
{f : ℕ → Ω → ℝ} [MeasureTheory.IsFiniteMeasure μ],
MeasureTheory.Submartingale f ℱ μ → ∀ (r : ℝ), MeasureTheory.Submartingale (MeasureTheory.stoppedAbove f r) ℱ μ |
OrderAddMonoidIso.toMultiplicativeRight._proof_1 | Mathlib.Algebra.Order.Hom.TypeTags | ∀ {G : Type u_2} {H : Type u_1} [inst : CommMonoid G] [inst_1 : PartialOrder G] [inst_2 : AddCommMonoid H]
[inst_3 : PartialOrder H] (e : Additive G ≃+o H) {a b : G},
(AddEquiv.toMultiplicativeRight e.toAddEquiv).toFun a ≤ (AddEquiv.toMultiplicativeRight e.toAddEquiv).toFun b ↔ a ≤ b |
DFinsupp.single_smul | Mathlib.Data.DFinsupp.Module | ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
[inst_2 : (i : ι) → SMulZeroClass γ (β i)] {i : ι} (c : γ) (x : β i), (fun₀ | i => c • x) = c • fun₀ | i => x |
CategoryTheory.SimplicialObject.IsCoskeletal.isUniversalOfIsRightKanExtension | Mathlib.AlgebraicTopology.SimplicialObject.Coskeletal | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(X : CategoryTheory.SimplicialObject C) →
(n : ℕ) →
[X.IsCoskeletal n] →
CategoryTheory.CostructuredArrow.IsUniversal
(CategoryTheory.SimplicialObject.Truncated.rightExtensionInclusion X n) |
CategoryTheory.GrothendieckTopology.plusFunctorWhiskerLeftIso_inv_app | Mathlib.CategoryTheory.Sites.CompatiblePlus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w₁}
[inst_1 : CategoryTheory.Category.{max v u, w₁} D] {E : Type w₂} [inst_2 : CategoryTheory.Category.{max v u, w₂} E]
[inst_3 :
∀ (J : CategoryTheory.Limits.MulticospanShape),
CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WalkingMulticospan J) D]
[inst_4 :
∀ (J : CategoryTheory.Limits.MulticospanShape),
CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WalkingMulticospan J) E]
[inst_5 : ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (J.Cover X)ᵒᵖ D]
[inst_6 : ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (J.Cover X)ᵒᵖ E] (P : CategoryTheory.Functor Cᵒᵖ D)
[inst_7 : ∀ (F : CategoryTheory.Functor D E) (X : C), CategoryTheory.Limits.PreservesColimitsOfShape (J.Cover X)ᵒᵖ F]
[inst_8 :
∀ (F : CategoryTheory.Functor D E) (X : C) (W : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D),
CategoryTheory.Limits.PreservesLimit (W.index P).multicospan F]
(X : CategoryTheory.Functor D E), (J.plusFunctorWhiskerLeftIso P).inv.app X = (J.plusCompIso X P).inv |
Lagrange.funEquivDegreeLT._proof_4 | Mathlib.LinearAlgebra.Lagrange | ∀ {F : Type u_1} [inst : Field F] {ι : Type u_2} [inst_1 : DecidableEq ι] {s : Finset ι} {v : ι → F}
(hvs : Set.InjOn v ↑s),
Function.RightInverse (fun r => ⟨(Lagrange.interpolate s v) fun x => if hx : x ∈ s then r ⟨x, hx⟩ else 0, ⋯⟩)
fun f i => Polynomial.eval (v ↑i) ↑f |
Set.Nonempty.nsmul | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddMonoid α] {s : Set α}, s.Nonempty → ∀ {n : ℕ}, (n • s).Nonempty |
_private.Batteries.Classes.SatisfiesM.0.MonadSatisfying.instEStateM.match_1.splitter | Batteries.Classes.SatisfiesM | {ε σ α : Type u_1} →
(motive : EStateM.Result ε σ α → Sort u_2) →
(x : EStateM.Result ε σ α) →
((a : α) → (s' : σ) → x = EStateM.Result.ok a s' → motive (EStateM.Result.ok a s')) →
((e : ε) → (s' : σ) → x = EStateM.Result.error e s' → motive (EStateM.Result.error e s')) → motive x |
Submonoid.topologicalClosure._proof_2 | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : Monoid M] (s : Submonoid M), 1 ∈ closure ↑s |
Lean.Meta.Match.Problem.mk.noConfusion | Lean.Meta.Match.Basic | {P : Sort u} →
{mvarId : Lean.MVarId} →
{vars : List Lean.Expr} →
{alts : List Lean.Meta.Match.Alt} →
{examples : List Lean.Meta.Match.Example} →
{mvarId' : Lean.MVarId} →
{vars' : List Lean.Expr} →
{alts' : List Lean.Meta.Match.Alt} →
{examples' : List Lean.Meta.Match.Example} →
{ mvarId := mvarId, vars := vars, alts := alts, examples := examples } =
{ mvarId := mvarId', vars := vars', alts := alts', examples := examples' } →
(mvarId = mvarId' → vars = vars' → alts = alts' → examples = examples' → P) → P |
RingCon.matrix | Mathlib.LinearAlgebra.Matrix.Ideal | {R : Type u_1} →
(n : Type u_2) → [inst : NonUnitalNonAssocSemiring R] → [inst_1 : Fintype n] → RingCon R → RingCon (Matrix n n R) |
_private.Init.Data.UInt.Lemmas.0.UInt16.ofBitVec_toBitVec.match_1_1 | Init.Data.UInt.Lemmas | ∀ (motive : UInt16 → Prop) (x : UInt16),
(∀ (val : ℕ) (isLt : val < 2 ^ 16), motive { toBitVec := { toFin := ⟨val, isLt⟩ } }) → motive x |
Std.TreeMap.getD_alter_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {fallback : β}
{f : Option β → Option β}, (t.alter k f).getD k fallback = (f t[k]?).getD fallback |
AddSubgroup.neg_subset_closure._simp_1 | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G] (S : Set G), (-S ⊆ ↑(AddSubgroup.closure S)) = True |
CategoryTheory.Functor.HomObj.mk.congr_simp | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{F G : CategoryTheory.Functor C D} {A : CategoryTheory.Functor C (Type w)}
(app app_1 : (c : C) → A.obj c → (F.obj c ⟶ G.obj c)) (e_app : app = app_1)
(naturality :
∀ {c d : C} (f : c ⟶ d) (a : A.obj c),
CategoryTheory.CategoryStruct.comp (F.map f) (app d (A.map f a)) =
CategoryTheory.CategoryStruct.comp (app c a) (G.map f)),
{ app := app, naturality := naturality } = { app := app_1, naturality := ⋯ } |
Std.ExtTreeMap.size_insertIfNew_le | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β}, (t.insertIfNew k v).size ≤ t.size + 1 |
CategoryTheory.Mon.instHasLimitsOfShape | Mathlib.CategoryTheory.Monoidal.Internal.Limits | ∀ {J : Type w} [inst : CategoryTheory.Category.{v_1, w} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasLimitsOfShape J C],
CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.Mon C) |
AddMonoidHom.inl._proof_1 | Mathlib.Algebra.Group.Prod | ∀ (M : Type u_1) (N : Type u_2) [inst : AddZeroClass M] [inst_1 : AddZeroClass N], (0, 0) = (0, 0) |
Stream'.map_eq | Mathlib.Data.Stream.Init | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Stream' α),
Stream'.map f s = Stream'.cons (f s.head) (Stream'.map f s.tail) |
_private.Mathlib.RingTheory.WittVector.Truncated.0._aux_Mathlib_RingTheory_WittVector_Truncated___macroRules__private_Mathlib_RingTheory_WittVector_Truncated_0_term𝕎_1 | Mathlib.RingTheory.WittVector.Truncated | Lean.Macro |
Lean.Language.ToSnapshotTree.mk | Lean.Language.Basic | {α : Type} → (α → Lean.Language.SnapshotTree) → Lean.Language.ToSnapshotTree α |
SSet.Subcomplex.PairingCore.IsInner.mk | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | ∀ {X : SSet} {A : X.Subcomplex} {h : A.PairingCore},
(∀ (s : h.ι), h.index s ≠ 0) → (∀ (s : h.ι), h.index s ≠ Fin.last (h.dim s + 1)) → h.IsInner |
intervalIntegral.measure_integral_sub_linear_isLittleO_of_tendsto_ae_of_le' | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {ι : Type u_1} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {c : E}
{l l' : Filter ℝ} {lt : Filter ι} {μ : MeasureTheory.Measure ℝ} {u v : ι → ℝ} [CompleteSpace E]
[l'.IsMeasurablyGenerated] [Filter.TendstoIxxClass Set.Ioc l l'],
StronglyMeasurableAtFilter f l' μ →
Filter.Tendsto f (l' ⊓ MeasureTheory.ae μ) (nhds c) →
μ.FiniteAtFilter l' →
Filter.Tendsto u lt l →
Filter.Tendsto v lt l →
u ≤ᶠ[lt] v →
(fun t => ∫ (x : ℝ) in u t..v t, f x ∂μ - μ.real (Set.Ioc (u t) (v t)) • c) =o[lt] fun t =>
μ.real (Set.Ioc (u t) (v t)) |
NonUnitalSubsemiring.map._proof_2 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u_2} {S : Type u_1} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
{F : Type u_3} [inst_2 : FunLike F R S] [inst_3 : NonUnitalRingHomClass F R S] (f : F) (s : NonUnitalSubsemiring R),
0 ∈ (AddSubmonoid.map (↑f) s.toAddSubmonoid).carrier |
CategoryTheory.Presieve.extend_agrees | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X Y : C}
{R : CategoryTheory.Presieve X} {x : CategoryTheory.Presieve.FamilyOfElements P R},
x.Compatible → ∀ {f : Y ⟶ X} (hf : R f), x.sieveExtend f ⋯ = x f hf |
Lean.Parser.Command.opaque | Lean.Parser.Command | Lean.Parser.Parser |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.mkMulEqProof.go._sparseCasesOn_4 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | {motive : Lean.Meta.Grind.Arith.Cutsat.MulEqProof✝ → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.MulEqProof✝¹) →
((k : ℤ) → (h : Lean.Expr) → motive (Lean.Meta.Grind.Arith.Cutsat.MulEqProof.const✝ k h)) →
((k : ℤ) → (a h : Lean.Expr) → motive (Lean.Meta.Grind.Arith.Cutsat.MulEqProof.mulVar✝ k a h)) →
(Nat.hasNotBit 3 (Lean.Meta.Grind.Arith.Cutsat.MulEqProof.ctorIdx✝ t) → motive t) → motive t |
_private.Batteries.CodeAction.Misc.0.Batteries.CodeAction.instanceStub.match_7 | Batteries.CodeAction.Misc | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((name : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const name us)) →
((x : Lean.Expr) → motive x) → motive x |
Aesop.RuleResult.proved.noConfusion | Aesop.Search.Expansion | {P : Sort u} →
{newRapps newRapps' : Array Aesop.RappRef} →
Aesop.RuleResult.proved newRapps = Aesop.RuleResult.proved newRapps' → (newRapps = newRapps' → P) → P |
Lean.Meta.Ext.isExtTheorem | Lean.Meta.Tactic.Ext | Lean.Name → Lean.CoreM Bool |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.balance2.match_1.eq_3 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} (motive : Batteries.RBNode α → α → Batteries.RBNode α → Sort u_2) (a : Batteries.RBNode α) (x : α)
(b : Batteries.RBNode α)
(h_1 :
(a : Batteries.RBNode α) →
(x : α) →
(b : Batteries.RBNode α) →
(y : α) →
(c : Batteries.RBNode α) →
(z : α) →
(d : Batteries.RBNode α) →
motive a x
(Batteries.RBNode.node Batteries.RBColor.red b y
(Batteries.RBNode.node Batteries.RBColor.red c z d)))
(h_2 :
(a : Batteries.RBNode α) →
(x : α) →
(b : Batteries.RBNode α) →
(y : α) →
(c : Batteries.RBNode α) →
(z : α) →
(d : Batteries.RBNode α) →
motive a x
(Batteries.RBNode.node Batteries.RBColor.red (Batteries.RBNode.node Batteries.RBColor.red b y c) z
d))
(h_3 : (a : Batteries.RBNode α) → (x : α) → (b : Batteries.RBNode α) → motive a x b),
(∀ (b_1 : Batteries.RBNode α) (y : α) (c : Batteries.RBNode α) (z : α) (d : Batteries.RBNode α),
b = Batteries.RBNode.node Batteries.RBColor.red b_1 y (Batteries.RBNode.node Batteries.RBColor.red c z d) →
False) →
(∀ (b_1 : Batteries.RBNode α) (y : α) (c : Batteries.RBNode α) (z : α) (d : Batteries.RBNode α),
b = Batteries.RBNode.node Batteries.RBColor.red (Batteries.RBNode.node Batteries.RBColor.red b_1 y c) z d →
False) →
(match a, x, b with
| a, x, Batteries.RBNode.node Batteries.RBColor.red b y (Batteries.RBNode.node Batteries.RBColor.red c z d) =>
h_1 a x b y c z d
| a, x, Batteries.RBNode.node Batteries.RBColor.red (Batteries.RBNode.node Batteries.RBColor.red b y c) z d =>
h_2 a x b y c z d
| a, x, b => h_3 a x b) =
h_3 a x b |
MeasureTheory.Measure.setIntegral_toReal_rnDeriv_eq_withDensity | Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} [MeasureTheory.SigmaFinite μ]
[MeasureTheory.SFinite ν] (s : Set α),
∫ (x : α) in s, (μ.rnDeriv ν x).toReal ∂ν = (ν.withDensity (μ.rnDeriv ν)).real s |
_private.Lean.Compiler.IR.Basic.0.Lean.IR.Alt.setBody.match_1 | Lean.Compiler.IR.Basic | (motive : Lean.IR.Alt → Lean.IR.FnBody → Sort u_1) →
(x : Lean.IR.Alt) →
(x_1 : Lean.IR.FnBody) →
((c : Lean.IR.CtorInfo) → (b b_1 : Lean.IR.FnBody) → motive (Lean.IR.Alt.ctor c b) b_1) →
((b b_1 : Lean.IR.FnBody) → motive (Lean.IR.Alt.default b) b_1) → motive x x_1 |
ZeroMemClass.coe_eq_zero._simp_1 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {A : Type u_3} {M₁ : Type u_4} [inst : SetLike A M₁] [inst_1 : Zero M₁] [hA : ZeroMemClass A M₁] {S' : A} {x : ↥S'},
(↑x = 0) = (x = 0) |
Lean.Try.Config.harder._default | Init.Try | Bool |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.