name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Monoid.PushoutI.NormalWord.head | Mathlib.GroupTheory.PushoutI | {ι : Type u_1} →
{G : ι → Type u_2} →
{H : Type u_3} →
[inst : (i : ι) → Group (G i)] →
[inst_1 : Group H] →
{φ : (i : ι) → H →* G i} → {d : Monoid.PushoutI.NormalWord.Transversal φ} → Monoid.PushoutI.NormalWord d → H |
Std.Time.TimeZone.instInhabitedUTLocal.default | Std.Time.Zoned.ZoneRules | Std.Time.TimeZone.UTLocal |
Lean.Lsp.DidCloseTextDocumentParams | Lean.Data.Lsp.TextSync | Type |
_private.Mathlib.Topology.UniformSpace.UniformConvergence.0.tendstoUniformlyOn_singleton_iff_tendsto._simp_1_3 | Mathlib.Topology.UniformSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l₁ : Filter α} {l₂ : Filter β},
Filter.Tendsto f l₁ l₂ = ∀ s ∈ l₂, f ⁻¹' s ∈ l₁ |
_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.Score.mk.sizeOf_spec | Lean.Data.FuzzyMatching | ∀ (inner : Int16), sizeOf { inner := inner } = 1 + sizeOf inner |
_private.Mathlib.RingTheory.IntegralClosure.IntegrallyClosed.0.Associated.pow_iff._simp_1_1 | Mathlib.RingTheory.IntegralClosure.IntegrallyClosed | ∀ {M : Type u_1} [inst : MonoidWithZero M] [IsLeftCancelMulZero M] {a b : M}, Associated a b = (a ∣ b ∧ b ∣ a) |
LibraryNote.norm_num_lemma_function_equality | Mathlib.Tactic.NormNum.Basic | Batteries.Util.LibraryNote |
AffineSubspace.instCompleteLattice._proof_2 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] (x x_1 : AffineSubspace k P), ↑x ⊆ ↑(affineSpan k (↑x ∪ ↑x_1)) |
padicNormE.defn | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (f : PadicSeq p) {ε : ℚ},
0 < ε → ∃ N, ∀ i ≥ N, padicNormE (Padic.mk f - ↑(↑f i)) < ε |
Lean.Grind.CommRing.Expr.denote_toPoly | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.CommRing α] (ctx : Lean.Grind.CommRing.Context α) (e : Lean.Grind.CommRing.Expr),
Lean.Grind.CommRing.Poly.denote ctx e.toPoly = Lean.Grind.CommRing.Expr.denote ctx e |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreCommRing.injEq | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ (a b : Lean.Expr) (ra rb : Lean.Grind.CommRing.Expr) (p : Lean.Grind.CommRing.Poly)
(lhs' : Lean.Meta.Grind.Arith.Linear.LinExpr) (a_1 b_1 : Lean.Expr) (ra_1 rb_1 : Lean.Grind.CommRing.Expr)
(p_1 : Lean.Grind.CommRing.Poly) (lhs'_1 : Lean.Meta.Grind.Arith.Linear.LinExpr),
(Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreCommRing a b ra rb p lhs' =
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreCommRing a_1 b_1 ra_1 rb_1 p_1 lhs'_1) =
(a = a_1 ∧ b = b_1 ∧ ra = ra_1 ∧ rb = rb_1 ∧ p = p_1 ∧ lhs' = lhs'_1) |
Complex.HadamardThreeLines.sSupNormIm | Mathlib.Analysis.Complex.Hadamard | {E : Type u_1} → [NormedAddCommGroup E] → (ℂ → E) → ℝ → ℝ |
NonUnitalSubalgebra.toNonUnitalSubsemiring'._proof_2 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
(S T : NonUnitalSubalgebra R A), S.toNonUnitalSubsemiring = T.toNonUnitalSubsemiring → S = T |
_private.Lean.Compiler.LCNF.ToMono.0.Lean.Compiler.LCNF.LetValue.toMono.match_3 | Lean.Compiler.LCNF.ToMono | (motive : Lean.Compiler.LCNF.DeclValue Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(x : Lean.Compiler.LCNF.DeclValue Lean.Compiler.LCNF.Purity.pure) →
((resultFVar : Lean.FVarId) →
(binderName : Lean.Name) →
(type : Lean.Expr) →
(callName : Lean.Name) →
(us : List Lean.Level) →
(callArgs : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) →
(retFVar : Lean.FVarId) →
motive
(Lean.Compiler.LCNF.DeclValue.code
(Lean.Compiler.LCNF.Code.let
{ fvarId := resultFVar, binderName := binderName, type := type,
value := Lean.Compiler.LCNF.LetValue.const callName us callArgs ⋯ }
(Lean.Compiler.LCNF.Code.return retFVar)))) →
((x : Lean.Compiler.LCNF.DeclValue Lean.Compiler.LCNF.Purity.pure) → motive x) → motive x |
FirstOrder.Language.orderLHom_onRelation | Mathlib.ModelTheory.Order | ∀ (L : FirstOrder.Language) [inst : L.IsOrdered] (x : ℕ) (x_1 : FirstOrder.Language.order.Relations x),
L.orderLHom.onRelation x_1 =
match x, x_1 with
| .(2), FirstOrder.Language.orderRel.le => FirstOrder.Language.leSymb |
_private.Mathlib.Data.Fin.Tuple.Basic.0.Fin.findX._proof_13 | Mathlib.Data.Fin.Tuple.Basic | ∀ {n : ℕ} (p : Fin n → Prop) (h : ∃ k, p k) (m : ℕ),
(∀ (j : ℕ) (hm : j < n - (m + 1)), ¬p ⟨j, ⋯⟩) → ¬p ⟨n - (m + 1), ⋯⟩ → ∀ (j_1 : ℕ) (h_1 : j_1 < n - m), ¬p ⟨j_1, ⋯⟩ |
CategoryTheory.Limits.Cofork.ofCocone | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C} →
CategoryTheory.Limits.Cocone F →
CategoryTheory.Limits.Cofork (F.map CategoryTheory.Limits.WalkingParallelPairHom.left)
(F.map CategoryTheory.Limits.WalkingParallelPairHom.right) |
CategoryTheory.Ind.yoneda.fullyFaithful | Mathlib.CategoryTheory.Limits.Indization.Category | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Ind.yoneda.FullyFaithful |
UniformConvergenceCLM.sub_apply | Mathlib.Topology.Algebra.Module.StrongTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_3}
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : TopologicalSpace F] [inst_8 : IsTopologicalAddGroup F]
(𝔖 : Set (Set E)) (f g : UniformConvergenceCLM σ F 𝔖) (x : E), (f - g) x = f x - g x |
_private.Std.Data.DHashMap.Basic.0.Std.DHashMap.Const.insertManyIfNewUnit._proof_2 | Std.Data.DHashMap.Basic | ∀ {α : Type u_1} {x : BEq α} {x_1 : Hashable α} {ρ : Type u_2} [inst : ForIn Id ρ α] (m : Std.DHashMap α fun x => Unit)
(l : ρ), (↑↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit ⟨m.inner, ⋯⟩ l)).WF |
Std.Sat.AIG.toGraphviz.toGraphvizString.match_1 | Std.Sat.AIG.Basic | {α : Type} →
(motive : Std.Sat.AIG.Decl α → Sort u_1) →
(x : Std.Sat.AIG.Decl α) →
(Unit → motive Std.Sat.AIG.Decl.false) →
((i : α) → motive (Std.Sat.AIG.Decl.atom i)) →
((l r : Std.Sat.AIG.Fanin) → motive (Std.Sat.AIG.Decl.gate l r)) → motive x |
Int.dvd_zero._simp_1 | Init.Data.Int.DivMod.Bootstrap | ∀ (n : ℤ), (n ∣ 0) = True |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF._proof_23 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ),
∀ upper < aig.decls.size,
∀ (state : Std.Sat.AIG.toCNF.State✝ aig),
(Std.Sat.AIG.toCNF.Cache.marks✝ (Std.Sat.AIG.toCNF.State.cache✝ state)).size = aig.decls.size →
¬upper < (Std.Sat.AIG.toCNF.Cache.marks✝¹ (Std.Sat.AIG.toCNF.State.cache✝¹ state)).size → False |
ProbabilityTheory.IsMeasurableRatCDF.measurable_stieltjesFunction | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} {f : α → ℚ → ℝ} [inst : MeasurableSpace α] (hf : ProbabilityTheory.IsMeasurableRatCDF f) (x : ℝ),
Measurable fun a => ↑(hf.stieltjesFunction a) x |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get_insertIfNew._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) |
_private.Init.Data.Format.Basic.0.Std.Format.WorkGroup.fla | Init.Data.Format.Basic | Std.Format.WorkGroup✝ → Std.Format.FlattenAllowability |
String.codepointPosToUtf8PosFrom | Lean.Data.Lsp.Utf16 | String → String.Pos.Raw → ℕ → String.Pos.Raw |
CategoryTheory.Subfunctor.Subpresheaf.image_iSup | Mathlib.CategoryTheory.Subfunctor.Image | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F F' : CategoryTheory.Functor C (Type w)} {ι : Type u_1}
(G : ι → CategoryTheory.Subfunctor F) (f : F ⟶ F'), (⨆ i, G i).image f = ⨆ i, (G i).image f |
Holor.cprankMax_1 | Mathlib.Data.Holor | ∀ {α : Type} {ds : List ℕ} [inst : Mul α] [inst_1 : AddMonoid α] {x : Holor α ds}, x.CPRankMax1 → Holor.CPRankMax 1 x |
Set.op_smul_set_mul_eq_mul_smul_set | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Semigroup α] (a : α) (s t : Set α), MulOpposite.op a • s * t = s * a • t |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsProperLinearSet.add_floor_neg_toNat_sum_eq | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_3} {s : Set (ι → ℕ)} (hs : IsProperLinearSet s) [inst : Finite ι] (x : ι → ℕ),
x + ∑ i, (-IsProperLinearSet.floor✝ hs x i).toNat • ↑i =
IsProperLinearSet.fract✝ hs x + ∑ i, (IsProperLinearSet.floor✝¹ hs x i).toNat • ↑i |
Concept.ofIsIntent._proof_1 | Mathlib.Order.Concept | ∀ {α : Type u_1} {β : Type u_2} (r : α → β → Prop) (t : Set β), lowerPolar r t = lowerPolar r t |
CategoryTheory.IsFiltered.isConnected | Mathlib.CategoryTheory.Filtered.Connected | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C], CategoryTheory.IsConnected C |
isClopen_iInter | Mathlib.Topology.AlexandrovDiscrete | ∀ {ι : Sort u_1} {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α] {f : ι → Set α},
(∀ (i : ι), IsClopen (f i)) → IsClopen (⋂ i, f i) |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabOfNatCore._sparseCasesOn_1 | Lean.PrettyPrinter.Delaborator.Builtins | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t |
matrixEquivTensor._proof_2 | Mathlib.RingTheory.MatrixAlgebra | ∀ (n : Type u_2) (R : Type u_1) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Fintype n] [inst_4 : DecidableEq n],
Function.RightInverse (MatrixEquivTensor.equiv n R A).invFun (MatrixEquivTensor.equiv n R A).toFun |
BitVec.mul_succ | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x * (y + 1#w) = x * y + x |
Equiv.IicFinsetSet._proof_2 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] (a : α),
Function.LeftInverse (fun b => ⟨↑b, ⋯⟩) fun b => ⟨↑b, ⋯⟩ |
nhdsWithin_extChartAt_target_eq_of_mem | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
{I : ModelWithCorners 𝕜 E H} [inst_5 : ChartedSpace H M] {x : M} {z : E},
z ∈ (extChartAt I x).target → nhdsWithin z (extChartAt I x).target = nhdsWithin z (Set.range ↑I) |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.existsRatHint_of_ratHintsExhaustive._proof_1_33 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound | ∀ (ratHints : Array (ℕ × Array ℕ)) (j : Fin (Array.map (fun x => x.1) ratHints).toList.length),
↑j < (Array.map (fun x => x.1) ratHints).size |
Std.Internal.List.getValue?_insertList | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l toInsert : List ((_ : α) × β)} {k : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.DistinctKeys toInsert →
Std.Internal.List.getValue? k (Std.Internal.List.insertList l toInsert) =
(Std.Internal.List.getValue? k toInsert).or (Std.Internal.List.getValue? k l) |
Algebra.norm | Mathlib.RingTheory.Norm.Defs | (R : Type u_1) → {S : Type u_2} → [inst : CommRing R] → [inst_1 : Ring S] → [Algebra R S] → S →* R |
HasFTaylorSeriesUpToOn.hasStrictFDerivAt | Mathlib.Analysis.Calculus.ContDiff.RCLike | ∀ {𝕂 : Type u_1} [inst : RCLike 𝕂] {E' : Type u_2} [inst_1 : NormedAddCommGroup E'] [inst_2 : NormedSpace 𝕂 E']
{F' : Type u_3} [inst_3 : NormedAddCommGroup F'] [inst_4 : NormedSpace 𝕂 F'] {n : WithTop ℕ∞} {s : Set E'}
{f : E' → F'} {x : E'} {p : E' → FormalMultilinearSeries 𝕂 E' F'},
HasFTaylorSeriesUpToOn n f p s →
n ≠ 0 → s ∈ nhds x → HasStrictFDerivAt f ((continuousMultilinearCurryFin1 𝕂 E' F') (p x 1)) x |
LinearEquiv.multilinearMapCongrRight.congr_simp | Mathlib.LinearAlgebra.Multilinear.Finsupp | ∀ {R : Type uR} (S : Type uS) {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} {M₃ : Type v₃} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : (i : ι) → Module R (M₁ i)] [inst_3 : AddCommMonoid M₂]
[inst_4 : Module R M₂] [inst_5 : Semiring S] [inst_6 : Module S M₂] [inst_7 : SMulCommClass R S M₂]
[inst_8 : AddCommMonoid M₃] [inst_9 : Module S M₃] [inst_10 : Module R M₃] [inst_11 : SMulCommClass R S M₃]
[inst_12 : LinearMap.CompatibleSMul M₂ M₃ S R] [inst_13 : LinearMap.CompatibleSMul M₃ M₂ S R] (g g_1 : M₂ ≃ₗ[R] M₃),
g = g_1 → LinearEquiv.multilinearMapCongrRight S g = LinearEquiv.multilinearMapCongrRight S g_1 |
RingCon.mk'._proof_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (c : RingCon R), ↑1 = ↑1 |
RingEquiv.piMulOpposite._proof_4 | Mathlib.Algebra.Ring.Equiv | ∀ {ι : Type u_1} (S : ι → Type u_2) [inst : (i : ι) → NonUnitalNonAssocSemiring (S i)] (x x_1 : ((i : ι) → S i)ᵐᵒᵖ),
(fun i => MulOpposite.op (MulOpposite.unop (x + x_1) i)) = fun i => MulOpposite.op (MulOpposite.unop (x + x_1) i) |
CategoryTheory.Dial.tensorUnit_rel | Mathlib.CategoryTheory.Dialectica.Monoidal | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C],
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Dial C)).rel = ⊤ |
Lean.Lsp.InlayHintParams.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} → {t t' : Lean.Lsp.InlayHintParams} → t = t' → Lean.Lsp.InlayHintParams.noConfusionType P t t' |
NNDist.mk.noConfusion | Mathlib.Topology.MetricSpace.Pseudo.Defs | {α : Type u_3} →
{P : Sort u} →
{nndist nndist' : α → α → NNReal} → { nndist := nndist } = { nndist := nndist' } → (nndist ≍ nndist' → P) → P |
Tropical.instAddCommSemigroupTropical._proof_2 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : LinearOrder R] (x x_1 : Tropical R), x + x_1 = x_1 + x |
threeGPFree_smul_set₀ | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ {α : Type u_2} [inst : CommMonoidWithZero α] [IsCancelMulZero α] [NoZeroDivisors α] {s : Set α} {a : α},
a ≠ 0 → (ThreeGPFree (a • s) ↔ ThreeGPFree s) |
ProbabilityTheory.Kernel.withDensity_zero' | Mathlib.Probability.Kernel.WithDensity | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (κ : ProbabilityTheory.Kernel α β)
[inst : ProbabilityTheory.IsSFiniteKernel κ], (κ.withDensity fun x x_1 => 0) = 0 |
CategoryTheory.Limits.ConeMorphism.w_assoc | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {A B : CategoryTheory.Limits.Cone F} (self : CategoryTheory.Limits.ConeMorphism A B)
(j : J) {Z : C} (h : F.obj j ⟶ Z),
CategoryTheory.CategoryStruct.comp self.hom (CategoryTheory.CategoryStruct.comp (B.π.app j) h) =
CategoryTheory.CategoryStruct.comp (A.π.app j) h |
IsTop.not_isBot | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : PartialOrder α] {a : α} [Nontrivial α], IsTop a → ¬IsBot a |
bddOrd_dual_comp_forget_to_bipointed | Mathlib.Order.Category.BddOrd | BddOrd.dual.comp (CategoryTheory.forget₂ BddOrd Bipointed) =
(CategoryTheory.forget₂ BddOrd Bipointed).comp Bipointed.swap |
_private.Mathlib.Topology.Algebra.Group.OpenMapping.0.isOpenMap_smul_of_sigmaCompact._simp_1_1 | Mathlib.Topology.Algebra.Group.OpenMapping | ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
IsOpenMap f = ∀ (x : X), nhds (f x) ≤ Filter.map f (nhds x) |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.Stained.toFMVarId.match_1 | Mathlib.Tactic.Linter.FlexibleLinter | (motive : Option Lean.LocalDecl → Sort u_1) →
(x : Option Lean.LocalDecl) → (Unit → motive none) → ((decl : Lean.LocalDecl) → motive (some decl)) → motive x |
Algebra.GrothendieckAddGroup.lift | Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup | {M : Type u_1} →
{G : Type u_2} →
[inst : AddCommMonoid M] → [inst_1 : AddCommGroup G] → (M →+ G) ≃ (Algebra.GrothendieckAddGroup M →+ G) |
_private.Lean.Elab.DocString.0.Lean.Doc.fixupInline.match_3 | Lean.Elab.DocString | (motive : Option Lean.Doc.ElabLink✝ → Sort u_1) →
(x : Option Lean.Doc.ElabLink✝¹) →
((name : Lean.StrLit) → motive (some { name := name })) → ((x : Option Lean.Doc.ElabLink✝²) → motive x) → motive x |
CategoryTheory.PrelaxFunctor.id._proof_3 | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | ∀ (B : Type u_2) [inst : CategoryTheory.Bicategory B] {a b : B} {f g h : a ⟶ b} (η : f ⟶ g) (θ : g ⟶ h),
(CategoryTheory.PrelaxFunctorStruct.id B).map₂ (CategoryTheory.CategoryStruct.comp η θ) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.PrelaxFunctorStruct.id B).map₂ η)
((CategoryTheory.PrelaxFunctorStruct.id B).map₂ θ) |
Lean.Data.AC.EvalInformation.evalOp | Init.Data.AC | {α : Sort u} → {β : Sort v} → [self : Lean.Data.AC.EvalInformation α β] → α → β → β → β |
Matrix.ProjectiveSpecialLinearGroup | Mathlib.LinearAlgebra.Matrix.ProjectiveSpecialLinearGroup | (n : Type u) → [DecidableEq n] → [Fintype n] → (R : Type v) → [CommRing R] → Type (max (max u v) v u) |
ByteArray.findFinIdx?.loop | Init.Data.ByteArray.Basic | (a : ByteArray) → (UInt8 → Bool) → ℕ → Option (Fin a.size) |
PointedCone.map_id | Mathlib.Geometry.Convex.Cone.Pointed | ∀ {R : Type u_1} {E : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid E] [inst_4 : Module R E] (C : PointedCone R E), PointedCone.map LinearMap.id C = C |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.differentiable_set_subset_D._simp_1_5 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) |
Plausible.TotalFunction.rec | Plausible.Functions | {α : Type u} →
{β : Type v} →
{motive : Plausible.TotalFunction α β → Sort u_1} →
((a : List ((_ : α) × β)) → (a_1 : β) → motive (Plausible.TotalFunction.withDefault a a_1)) →
(t : Plausible.TotalFunction α β) → motive t |
CategoryTheory.Functor.IsStronglyCocartesian.mk._flat_ctor | Mathlib.CategoryTheory.FiberedCategory.Cocartesian | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} {R S : 𝒮} {a b : 𝒳} {f : R ⟶ S} {φ : a ⟶ b} [toIsHomLift : p.IsHomLift f φ],
(∀ {b' : 𝒳} (g : S ⟶ p.obj b') (φ' : a ⟶ b') [p.IsHomLift (CategoryTheory.CategoryStruct.comp f g) φ'],
∃! χ, p.IsHomLift g χ ∧ CategoryTheory.CategoryStruct.comp φ χ = φ') →
p.IsStronglyCocartesian f φ |
_private.Init.Data.Vector.Perm.0.Vector.swap_perm._simp_1_2 | Init.Data.Vector.Perm | ∀ {α : Type u_1} {n : ℕ} {as bs : Vector α n}, as.Perm bs = as.toList.Perm bs.toList |
Mathlib.Tactic.Push.pullStep | Mathlib.Tactic.Push | Mathlib.Tactic.Push.Head → Lean.Meta.Simp.Simproc |
Function.locallyFinsuppWithin.restrictMonoidHom_apply | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddCommGroup Y] {V : Set X}
(D : Function.locallyFinsuppWithin U Y) (h : V ⊆ U),
(Function.locallyFinsuppWithin.restrictMonoidHom h) D = D.restrict h |
_private.Lean.Meta.Sym.Simp.Rewrite.0.Lean.Meta.Sym.Simp.Theorem.rewrite._sparseCasesOn_4 | Lean.Meta.Sym.Simp.Rewrite | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t |
_private.Lean.Elab.DocString.0.Lean.Doc.findShadowedNames.match_3 | Lean.Elab.DocString | {α : Type} →
(motive : Lean.Name × α → Sort u_1) →
(x : Lean.Name × α) → ((fullName : Lean.Name) → (snd : α) → motive (fullName, snd)) → motive x |
FiberPrebundle.pretrivializationAt | Mathlib.Topology.FiberBundle.Basic | {B : Type u_2} →
{F : Type u_3} →
{E : B → Type u_5} →
[inst : TopologicalSpace B] →
[inst_1 : TopologicalSpace F] →
[inst_2 : (x : B) → TopologicalSpace (E x)] →
FiberPrebundle F E → B → Bundle.Pretrivialization F Bundle.TotalSpace.proj |
Aesop.ExtResult._sizeOf_1 | Aesop.Util.Tactic.Ext | Aesop.ExtResult → ℕ |
UInt64.toUInt16_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a.toUInt16 < b.toUInt16 ↔ a % 65536 < b % 65536 |
CategoryTheory.regularTopology.EqualizerCondition.bijective_mapToEqualizer_pullback | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.Functor Cᵒᵖ (Type u_4)},
CategoryTheory.regularTopology.EqualizerCondition P →
∀ {X B : C} (π : X ⟶ B) [CategoryTheory.EffectiveEpi π] [inst_2 : CategoryTheory.Limits.HasPullback π π],
Function.Bijective
(CategoryTheory.regularTopology.mapToEqualizer P π (CategoryTheory.Limits.pullback.fst π π)
(CategoryTheory.Limits.pullback.snd π π) ⋯) |
collinear_empty | Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional | ∀ (k : Type u_1) {V : Type u_2} (P : Type u_3) [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P], Collinear k ∅ |
Lean.Lsp.ReferenceParams.context | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ReferenceParams → Lean.Lsp.ReferenceContext |
CategoryTheory.Abelian.extFunctor_obj | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] (n : ℕ) (X : Cᵒᵖ),
(CategoryTheory.Abelian.extFunctor n).obj X = CategoryTheory.Abelian.extFunctorObj (Opposite.unop X) n |
_private.Mathlib.Algebra.Homology.Embedding.CochainComplex.0.CochainComplex.quasiIso_truncGEMap_iff._proof_1_1 | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ (n : ℤ) (i : ℕ), n ≤ n + ↑i |
MeasurableSpace.measurableSet_empty | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_7} (self : MeasurableSpace α), MeasurableSpace.MeasurableSet' self ∅ |
ContinuousMultilinearMap.ratio_le_opNorm | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι]
(f : ContinuousMultilinearMap 𝕜 E G) (m : (i : ι) → E i), ‖f m‖ / ∏ i, ‖m i‖ ≤ ‖f‖ |
Lean.Meta.Match.Example.val.noConfusion | Lean.Meta.Match.Basic | {P : Sort u} → {a a' : Lean.Expr} → Lean.Meta.Match.Example.val a = Lean.Meta.Match.Example.val a' → (a = a' → P) → P |
Mathlib.Tactic.BicategoryLike.MkEqOfNaturality.casesOn | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | {m : Type → Type} →
{motive : Mathlib.Tactic.BicategoryLike.MkEqOfNaturality m → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.MkEqOfNaturality m) →
((mkEqOfNaturality :
Lean.Expr →
Lean.Expr →
Mathlib.Tactic.BicategoryLike.IsoLift →
Mathlib.Tactic.BicategoryLike.IsoLift →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso → Lean.Expr → Lean.Expr → m Lean.Expr) →
motive { mkEqOfNaturality := mkEqOfNaturality }) →
motive t |
Batteries.PairingHeapImp.Heap.NodeWF._sunfold | Batteries.Data.PairingHeap | {α : Type u_1} → (α → α → Bool) → α → Batteries.PairingHeapImp.Heap α → Prop |
Lean.Elab.Tactic.Do.SpecAttr.SpecTheorems | Lean.Elab.Tactic.Do.Attr | Type |
Aesop.SimpResult.simplified | Aesop.Search.Expansion.Simp | Lean.MVarId → Lean.Meta.Simp.UsedSimps → Aesop.SimpResult |
Real.sInf_nonpos | Mathlib.Data.Real.Archimedean | ∀ {s : Set ℝ}, (∀ x ∈ s, x ≤ 0) → sInf s ≤ 0 |
Lean.Meta.initFn._@.Lean.Meta.Tactic.Util.3824588779._hygCtx._hyg.4 | Lean.Meta.Tactic.Util | IO (Lean.Option Bool) |
Lean.Lsp.instFromJsonTextDocumentContentChangeEvent | Lean.Data.Lsp.TextSync | Lean.FromJson Lean.Lsp.TextDocumentContentChangeEvent |
SchwartzMap.integralCLM._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {D : Type u_1} [inst : NormedAddCommGroup D] (n : ℕ) (x : D), 0 < (1 + ‖x‖) ^ ↑n |
Valuation.Integers.one_of_isUnit | Mathlib.RingTheory.Valuation.Integers | ∀ {R : Type u} {Γ₀ : Type v} [inst : CommRing R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] {v : Valuation R Γ₀}
{O : Type w} [inst_2 : CommRing O] [inst_3 : Algebra O R],
v.Integers O → ∀ {x : O}, IsUnit x → v ((algebraMap O R) x) = 1 |
_private.Mathlib.Data.Vector3.0.Fin2.add.match_1.eq_1 | Mathlib.Data.Vector3 | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (k : ℕ) → motive k.succ),
(match 0 with
| 0 => h_1 ()
| k.succ => h_2 k) =
h_1 () |
CategoryTheory.StrictlyUnitaryLaxFunctorCore.map | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
(self : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) → {X Y : B} → (X ⟶ Y) → (self.obj X ⟶ self.obj Y) |
CategoryTheory.Localization.Preadditive.add | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Preadditive | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[CategoryTheory.Preadditive C] →
{L : CategoryTheory.Functor C D} →
(W : CategoryTheory.MorphismProperty C) →
[L.IsLocalization W] →
[W.HasLeftCalculusOfFractions] →
{X Y : C} → {X' Y' : D} → (L.obj X ≅ X') → (L.obj Y ≅ Y') → (X' ⟶ Y') → (X' ⟶ Y') → (X' ⟶ Y') |
SimpleGraph.induceHom_injective | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {G' : SimpleGraph W} {s : Set V} {t : Set W} (φ : G →g G')
(φst : Set.MapsTo (⇑φ) s t), Set.InjOn (⇑φ) s → Function.Injective ⇑(SimpleGraph.induceHom φ φst) |
Std.HashMap.getKey!_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α Unit} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {l : List α} {k k' : α},
(k == k') = true →
k ∉ m → List.Pairwise (fun a b => (a == b) = false) l → k ∈ l → (m.insertManyIfNewUnit l).getKey! k' = k |
Lean.StructureResolutionOrderResult.mk.noConfusion | Lean.Structure | {P : Sort u} →
{resolutionOrder : Array Lean.Name} →
{conflicts : Array Lean.StructureResolutionOrderConflict} →
{resolutionOrder' : Array Lean.Name} →
{conflicts' : Array Lean.StructureResolutionOrderConflict} →
{ resolutionOrder := resolutionOrder, conflicts := conflicts } =
{ resolutionOrder := resolutionOrder', conflicts := conflicts' } →
(resolutionOrder = resolutionOrder' → conflicts = conflicts' → P) → P |
RootPairing.CorootForm | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | {ι : 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] → RootPairing ι R M N → [Fintype ι] → LinearMap.BilinForm R N |
Std.TreeSet.Raw.size_insertMany_list_le | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {l : List α}, (t.insertMany l).size ≤ t.size + l.length |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.