name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.Dial.tensorObjImpl._proof_2 | Mathlib.CategoryTheory.Dialectica.Monoidal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
(X Y : CategoryTheory.Dial C), CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.pair X.tgt Y.tgt) |
Lean.Meta.instDecidableEqProjReductionKind._proof_1 | Lean.Meta.Basic | ∀ (x y : Lean.Meta.ProjReductionKind), x.ctorIdx = y.ctorIdx → x = y |
WeaklyLawfulMonadAttach.casesOn | Init.Control.MonadAttach | {m : Type u → Type v} →
[inst : Monad m] →
[inst_1 : MonadAttach m] →
{motive : WeaklyLawfulMonadAttach m → Sort u_1} →
(t : WeaklyLawfulMonadAttach m) →
((map_attach : ∀ {α : Type u} {x : m α}, Subtype.val <$> MonadAttach.attach x = x) → motive ⋯) → motive t |
_private.Init.Data.BitVec.Lemmas.0.BitVec.cpop_cons._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ (n : ℕ), (n < n + 1) = True |
Plausible.Gen.chooseNat | Plausible.Gen | Plausible.Gen ℕ |
Lean.Meta.Grind.Arith.Linear.pp? | Lean.Meta.Tactic.Grind.Arith.Linear.PP | Lean.Meta.Grind.Goal → Lean.MetaM (Option Lean.MessageData) |
CategoryTheory.ComposableArrows.Precomp.map.congr_simp | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C}
(f f_1 : X ⟶ F.left),
f = f_1 →
∀ (i j : Fin (n + 1 + 1)) (x : i ≤ j),
CategoryTheory.ComposableArrows.Precomp.map F f i j x = CategoryTheory.ComposableArrows.Precomp.map F f_1 i j x |
Set.empty_disjoint._simp_1 | Mathlib.Data.Set.Disjoint | ∀ {α : Type u} (s : Set α), Disjoint ∅ s = True |
_private.Lean.Elab.Tactic.Grind.Main.0.Lean.Elab.Tactic.evalGrindTraceCore.match_3 | Lean.Elab.Tactic.Grind.Main | (motive : Lean.Meta.Grind.ActionResult → Sort u_1) →
(__do_lift : Lean.Meta.Grind.ActionResult) →
((seq : List Lean.Meta.Grind.TGrind) → motive (Lean.Meta.Grind.ActionResult.closed seq)) →
((gs : List Lean.Meta.Grind.Goal) → motive (Lean.Meta.Grind.ActionResult.stuck gs)) → motive __do_lift |
ProofWidgets.Jsx.delabHtmlOfComponent' | ProofWidgets.Data.Html | Lean.PrettyPrinter.Delaborator.DelabM (Lean.TSyntax `jsxElement) |
Group.rootableByNatOfRootableByInt.eq_1 | Mathlib.GroupTheory.Divisible | ∀ (A : Type u_1) [inst : Group A] [inst_1 : RootableBy A ℤ],
Group.rootableByNatOfRootableByInt A = { root := fun a n => RootableBy.root a ↑n, root_zero := ⋯, root_cancel := ⋯ } |
Rat.zero_add | Init.Data.Rat.Lemmas | ∀ (a : ℚ), 0 + a = a |
uniform_continuous_npow_on_bounded | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] (B : α) {ε : α},
0 < ε → ∀ (n : ℕ), ∃ δ > 0, ∀ (q r : α), |r| ≤ B → |q - r| ≤ δ → |q ^ n - r ^ n| < ε |
EuclideanGeometry.image_inversion_sphere_dist_center | Mathlib.Geometry.Euclidean.Inversion.ImageHyperplane | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c y : P} {R : ℝ},
R ≠ 0 →
y ≠ c →
EuclideanGeometry.inversion c R '' Metric.sphere y (dist y c) =
insert c ↑(AffineSubspace.perpBisector c (EuclideanGeometry.inversion c R y)) |
_private.Mathlib.CategoryTheory.Presentable.OrthogonalReflection.0.CategoryTheory.OrthogonalReflection.toSucc_surjectivity._simp_1_1 | Mathlib.CategoryTheory.Presentable.OrthogonalReflection | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} {Z : C}
[inst_1 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁]
[inst_2 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₂] {X Y : C} (f : X ⟶ Y)
(hf : W f) (g : X ⟶ Z) {Z_1 : C} (h : ∐ CategoryTheory.OrthogonalReflection.D₁.obj₂ ⟶ Z_1),
CategoryTheory.CategoryStruct.comp f
(CategoryTheory.CategoryStruct.comp (CategoryTheory.OrthogonalReflection.D₁.ιRight f hf g) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.OrthogonalReflection.D₁.ιLeft f hf g)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.OrthogonalReflection.D₁.t W Z) h) |
UniformConcaveOn | Mathlib.Analysis.Convex.Strong | {E : Type u_1} → [inst : NormedAddCommGroup E] → [NormedSpace ℝ E] → Set E → (ℝ → ℝ) → (E → ℝ) → Prop |
CategoryTheory.GrothendieckTopology.Point | Mathlib.CategoryTheory.Sites.Point.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.GrothendieckTopology C → Type (max (max u v) (w + 1)) |
CategoryTheory.Limits.colimitHomIsoLimitYoneda._proof_1 | Mathlib.CategoryTheory.Limits.IndYoneda | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {I : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} I] (F : CategoryTheory.Functor I C) [CategoryTheory.Limits.HasColimit F]
(A : C), CategoryTheory.Limits.HasLimit (F.op.comp (CategoryTheory.yoneda.obj A)) |
Subalgebra.equivOfEq._proof_4 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S T : Subalgebra R A), S = T → ∀ (x : ↥T), ↑x ∈ S |
Lean.Lsp.instToJsonInitializeResult | Lean.Data.Lsp.InitShutdown | Lean.ToJson Lean.Lsp.InitializeResult |
Std.ExtTreeMap.getElem!_eq_default | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited β] {a : α}, a ∉ t → t[a]! = default |
Lean.Grind.Linarith.Expr.collectVars | Lean.Meta.Tactic.Grind.Arith.Linear.VarRename | Lean.Grind.Linarith.Expr → Lean.Meta.Grind.VarCollector |
_private.Lean.Meta.InferType.0.Lean.Meta.isPropQuickApp._unsafe_rec | Lean.Meta.InferType | Lean.Expr → ℕ → Lean.MetaM Lean.LBool |
RpcEncodablePacket.«_@».Mathlib.Tactic.Widget.SelectPanelUtils.2749655504._hygCtx._hyg.1.noConfusion | Mathlib.Tactic.Widget.SelectPanelUtils | {P : Sort u} →
{t t' : RpcEncodablePacket✝} →
t = t' →
RpcEncodablePacket.«_@».Mathlib.Tactic.Widget.SelectPanelUtils.2749655504._hygCtx._hyg.1.noConfusionType P t t' |
_private.Lean.Elab.Tactic.BVDecide.LRAT.Trim.0.Lean.Elab.Tactic.BVDecide.LRAT.trim.useAnalysis.go.match_1 | Lean.Elab.Tactic.BVDecide.LRAT.Trim | (motive : Option Std.Tactic.BVDecide.LRAT.IntAction → Sort u_1) →
(step? : Option Std.Tactic.BVDecide.LRAT.IntAction) →
((step : Std.Tactic.BVDecide.LRAT.IntAction) → motive (some step)) → (Unit → motive none) → motive step? |
IntermediateField.adjoinRootEquivAdjoin._proof_1 | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | ∀ (F : Type u_1) [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {α : E},
IsIntegral F α →
Function.Bijective
⇑(AdjoinRoot.liftAlgHom (minpoly F α) (Algebra.ofId F ↥F⟮α⟯) (IntermediateField.AdjoinSimple.gen F α) ⋯) |
Aesop.Goal.instBEq | Aesop.Tree.Data | BEq Aesop.Goal |
Stream'.append_append_stream | Mathlib.Data.Stream.Init | ∀ {α : Type u} (l₁ l₂ : List α) (s : Stream' α), l₁ ++ l₂ ++ₛ s = l₁ ++ₛ (l₂ ++ₛ s) |
Nat.nth._proof_1 | Mathlib.Data.Nat.Nth | ∀ (p : ℕ → Prop), ¬(setOf p).Finite → Infinite ↑(setOf p) |
AddCommMonCat.instConcreteCategoryAddMonoidHomCarrier._proof_3 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X : AddCommMonCat} (x : ↑X), (CategoryTheory.CategoryStruct.id X).hom' x = x |
ArithmeticFunction.carmichael_finset_prod | Mathlib.NumberTheory.ArithmeticFunction.Carmichael | ∀ {α : Type u_2} {s : Finset α} {f : α → ℕ},
(↑s).Pairwise (Function.onFun Nat.Coprime f) →
ArithmeticFunction.Carmichael (s.prod f) = s.lcm (⇑ArithmeticFunction.Carmichael ∘ f) |
Array.foldl_cons_eq_append | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {stop : ℕ} {as : Array α} {bs : List β} {f : α → β},
stop = as.size → Array.foldl (fun acc a => f a :: acc) bs as 0 stop = (Array.map f as).reverse.toList ++ bs |
ContinuousMultilinearMap.isUniformEmbedding_toUniformOnFun | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {F : Type u_4} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : UniformSpace F]
[inst_7 : IsUniformAddGroup F], IsUniformEmbedding ContinuousMultilinearMap.toUniformOnFun |
Ctop.Realizer.is_basis | Mathlib.Data.Analysis.Topology | ∀ {α : Type u_1} [T : TopologicalSpace α] (F : Ctop.Realizer α), TopologicalSpace.IsTopologicalBasis (Set.range F.F.f) |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.link2.match_1.eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} (l l'' : Std.DTreeMap.Internal.Impl α β)
(motive : Std.DTreeMap.Internal.Impl.Tree α β (l.size + l''.size) → Sort u_3) (ℓ : Std.DTreeMap.Internal.Impl α β)
(hℓ₁ : ℓ.Balanced) (hℓ₂ : ℓ.size = l.size + l''.size)
(h_1 :
(ℓ : Std.DTreeMap.Internal.Impl α β) →
(hℓ₁ : ℓ.Balanced) →
(hℓ₂ : ℓ.size = l.size + l''.size) → motive { impl := ℓ, balanced_impl := hℓ₁, size_impl := hℓ₂ }),
(match { impl := ℓ, balanced_impl := hℓ₁, size_impl := hℓ₂ } with
| { impl := ℓ, balanced_impl := hℓ₁, size_impl := hℓ₂ } => h_1 ℓ hℓ₁ hℓ₂) =
h_1 ℓ hℓ₁ hℓ₂ |
Lean.Meta.Grind.instInhabitedEMatchTheorem | Lean.Meta.Tactic.Grind.Extension | Inhabited Lean.Meta.Grind.EMatchTheorem |
_private.Mathlib.Topology.EMetricSpace.Basic.0.EMetric.nontrivial_iff_nontrivialTopology._simp_1_3 | Mathlib.Topology.EMetricSpace.Basic | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α}, Inseparable x y = (edist x y = 0) |
Valuation.map_add_eq_of_lt_right | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀)
{x y : R}, v x < v y → v (x + y) = v y |
ChainComplex.fromSingle₀Equiv._proof_4 | Mathlib.Algebra.Homology.Single | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
[inst_2 : CategoryTheory.Limits.HasZeroObject V] (C : ChainComplex V ℕ) (X : V),
Function.LeftInverse (fun f => HomologicalComplex.mkHomFromSingle f ⋯) fun f => f.f 0 |
AlgEquiv.casesOn | Mathlib.Algebra.Algebra.Equiv | {R : Type u} →
{A : Type v} →
{B : Type w} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] →
[inst_3 : Algebra R A] →
[inst_4 : Algebra R B] →
{motive : (A ≃ₐ[R] B) → Sort u_1} →
(t : A ≃ₐ[R] B) →
((toEquiv : A ≃ B) →
(map_mul' : ∀ (x y : A), toEquiv.toFun (x * y) = toEquiv.toFun x * toEquiv.toFun y) →
(map_add' : ∀ (x y : A), toEquiv.toFun (x + y) = toEquiv.toFun x + toEquiv.toFun y) →
(commutes' : ∀ (r : R), toEquiv.toFun ((algebraMap R A) r) = (algebraMap R B) r) →
motive
{ toEquiv := toEquiv, map_mul' := map_mul', map_add' := map_add',
commutes' := commutes' }) →
motive t |
CategoryTheory.Limits.zeroProdIso | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] → (X : C) → 0 ⨯ X ≅ X |
_private.Mathlib.Geometry.Euclidean.Similarity.0.EuclideanGeometry.similar_of_side_angle_side._proof_1_10 | Mathlib.Geometry.Euclidean.Similarity | ∀ {P₁ : Type u_1} {P₂ : Type u_2} [inst : MetricSpace P₁] [inst_1 : MetricSpace P₂] {a b c : P₁} {a' b' c' : P₂},
dist c a = dist a b / dist a' b' * dist c' a' → dist c a = dist a b / dist a' b' * dist c' a' |
Quotient.liftOn₂.congr_simp | Mathlib.Data.Fintype.Quotient | ∀ {α : Sort uA} {β : Sort uB} {φ : Sort uC} {s₁ : Setoid α} {s₂ : Setoid β} (q₁ q₁_1 : Quotient s₁),
q₁ = q₁_1 →
∀ (q₂ q₂_1 : Quotient s₂),
q₂ = q₂_1 →
∀ (f f_1 : α → β → φ) (e_f : f = f_1)
(c : ∀ (a₁ : α) (b₁ : β) (a₂ : α) (b₂ : β), a₁ ≈ a₂ → b₁ ≈ b₂ → f a₁ b₁ = f a₂ b₂),
q₁.liftOn₂ q₂ f c = q₁_1.liftOn₂ q₂_1 f_1 ⋯ |
MulMemClass.subtype | Mathlib.Algebra.Group.Subsemigroup.Defs | {M : Type u_1} →
{A : Type u_3} → [inst : Mul M] → [inst_1 : SetLike A M] → [hA : MulMemClass A M] → (S' : A) → ↥S' →ₙ* M |
MeasureTheory.condExpL1CLM_indicatorConst | Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL1 | ∀ {α : Type u_1} {F' : Type u_3} [inst : NormedAddCommGroup F'] [inst_1 : NormedSpace ℝ F'] [inst_2 : CompleteSpace F']
{m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {hm : m ≤ m0}
[inst_3 : MeasureTheory.SigmaFinite (μ.trim hm)] {s : Set α} (hs : MeasurableSet s) (hμs : μ s ≠ ⊤) (x : F'),
(MeasureTheory.condExpL1CLM F' hm μ) ↑(MeasureTheory.Lp.simpleFunc.indicatorConst 1 hs hμs x) =
(MeasureTheory.condExpInd F' hm μ s) x |
definition._@.Mathlib.Algebra.BigOperators.Finprod.1839979836._hygCtx._hyg.8 | Mathlib.Algebra.BigOperators.Finprod | {M : Type u_2} → {α : Sort u_4} → [AddCommMonoid M] → (α → M) → M |
UniformOnFun.gen_mono | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} {S S' : Set α} {V V' : Set (β × β)},
S' ⊆ S → V ⊆ V' → UniformOnFun.gen 𝔖 S V ⊆ UniformOnFun.gen 𝔖 S' V' |
_private.Lean.Meta.Basic.0.Lean.Meta.ExprConfigCacheKey.mk.inj | Lean.Meta.Basic | ∀ {expr : Lean.Expr} {configKey : UInt64} {expr_1 : Lean.Expr} {configKey_1 : UInt64},
{ expr := expr, configKey := configKey } = { expr := expr_1, configKey := configKey_1 } →
expr = expr_1 ∧ configKey = configKey_1 |
AddSemigrp.Hom.casesOn | Mathlib.Algebra.Category.Semigrp.Basic | {A B : AddSemigrp} →
{motive : A.Hom B → Sort u_1} → (t : A.Hom B) → ((hom' : ↑A →ₙ+ ↑B) → motive { hom' := hom' }) → motive t |
invertibleTwo._proof_2 | Mathlib.Algebra.CharP.Invertible | (1 + 1).AtLeastTwo |
ergodic_smul_of_denseRange_pow | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {X : Type u_2} [inst : TopologicalSpace X] [R1Space X] [inst_2 : MeasurableSpace X] [BorelSpace X] {M : Type u_3}
[inst_4 : Monoid M] [inst_5 : TopologicalSpace M] [inst_6 : MulAction M X] [ContinuousSMul M X] {g : M},
(DenseRange fun x => g ^ x) →
∀ (μ : MeasureTheory.Measure X) [MeasureTheory.IsFiniteMeasure μ] [μ.InnerRegular] [ErgodicSMul M X μ],
Ergodic (fun x => g • x) μ |
Derivation.leibniz | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M] (D : Derivation R A M)
(a b : A), D (a * b) = a • D b + b • D a |
Lean.ErrorExplanation.instToJsonMetadata.toJson | Lean.ErrorExplanation | Lean.ErrorExplanation.Metadata → Lean.Json |
Metric.cthickening_empty | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] (δ : ℝ), Metric.cthickening δ ∅ = ∅ |
_private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.tendsto_pow_logb_div_mul_add_atTop._simp_1_8 | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False |
Std.IterM.all_eq_allM | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [Std.Iterators.Finite α m] [inst_2 : Monad m]
[LawfulMonad m] [inst_4 : Std.IteratorLoop α m m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β} {p : β → Bool},
Std.IterM.all p it = Std.IterM.allM (fun x => pure { down := p x }) it |
ModuleCat.projective_of_module_projective | Mathlib.Algebra.Category.ModuleCat.Projective | ∀ {R : Type u} [inst : Ring R] (P : ModuleCat R) [Small.{v, u} R] [CategoryTheory.Projective P], Module.Projective R ↑P |
Nonneg.instContinuousFunctionalCalculus | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances | ∀ {A : Type u_1} [inst : Ring A] [inst_1 : PartialOrder A] [inst_2 : StarRing A] [StarOrderedRing A]
[inst_4 : TopologicalSpace A] [inst_5 : Algebra ℝ A] [ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[NonnegSpectrumClass ℝ A], ContinuousFunctionalCalculus NNReal A fun x => 0 ≤ x |
Set.Finset.coe_einfsep | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u_1} [inst : EDist α] {s : Finset α}, (↑s).einfsep = s.offDiag.inf (Function.uncurry edist) |
_private.Mathlib.MeasureTheory.Measure.Doubling.0.IsUnifLocDoublingMeasure.eventually_measure_mul_le_scalingConstantOf_mul._simp_1_1 | Mathlib.MeasureTheory.Measure.Doubling | ∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : LE α] [CanonicallyOrderedAdd α] (a : α), (0 ≤ a) = True |
instAntisymmLe | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : PartialOrder α], Std.Antisymm fun x1 x2 => x1 ≤ x2 |
Std.DTreeMap.Raw.mem_alter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t.WF →
∀ {k k' : α} {f : Option (β k) → Option (β k)},
k' ∈ t.alter k f ↔ if cmp k k' = Ordering.eq then (f (t.get? k)).isSome = true else k' ∈ t |
TopologicalSpace.Opens.coe_compl | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_2} [inst : TopologicalSpace α] (s : TopologicalSpace.Opens α), ↑s.compl = (↑s)ᶜ |
Lean.trace.profiler.threshold | Lean.Util.Trace | Lean.Option ℕ |
RelHom.coe_mul | Mathlib.Algebra.Order.Group.End | ∀ {α : Type u_1} {r : α → α → Prop} (f g : r →r r), ⇑(f * g) = ⇑f ∘ ⇑g |
StateTransition.evalInduction._proof_1 | Mathlib.Computability.StateTransition | ∀ {σ : Type u_1} {f : σ → Option σ} (a' b' : σ), f a' = some b' → Sum.inr b' = (f a').elim (Sum.inl a') Sum.inr |
_private.Mathlib.RingTheory.WittVector.FrobeniusFractionField.0.WittVector.frobeniusRotationCoeff.match_1.splitter | Mathlib.RingTheory.WittVector.FrobeniusFractionField | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x |
ContinuousLinearMap.opNorm_le_bound₂ | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} {E : Type u_4} {F : Type u_6} {G : Type u_8}
[inst : SeminormedAddCommGroup E] [inst_1 : SeminormedAddCommGroup F] [inst_2 : SeminormedAddCommGroup G]
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NontriviallyNormedField 𝕜₂] [inst_5 : NontriviallyNormedField 𝕜₃]
[inst_6 : NormedSpace 𝕜 E] [inst_7 : NormedSpace 𝕜₂ F] [inst_8 : NormedSpace 𝕜₃ G] {σ₂₃ : 𝕜₂ →+* 𝕜₃} {σ₁₃ : 𝕜 →+* 𝕜₃}
[inst_9 : RingHomIsometric σ₂₃] (f : E →SL[σ₁₃] F →SL[σ₂₃] G) {C : ℝ},
0 ≤ C → (∀ (x : E) (y : F), ‖(f x) y‖ ≤ C * ‖x‖ * ‖y‖) → ‖f‖ ≤ C |
ContinuousLinearMap.seminorm._proof_3 | Mathlib.Analysis.Normed.Operator.Basic | ∀ {F : Type u_1} [inst : SeminormedAddCommGroup F], ContinuousAdd F |
Std.Internal.IO.Async.instMonadAsyncStateRefT' | Std.Internal.Async.Basic | {t m : Type → Type} →
{s n : Type} → [Std.Internal.IO.Async.MonadAsync t m] → Std.Internal.IO.Async.MonadAsync t (StateRefT' s n m) |
_private.Mathlib.Combinatorics.SetFamily.Compression.Down.0.Down.erase_mem_compression_of_mem_compression._simp_1_1 | Mathlib.Combinatorics.SetFamily.Compression.Down | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α} {a : α},
(s ∈ Down.compression a 𝒜) = (s ∈ 𝒜 ∧ s.erase a ∈ 𝒜 ∨ s ∉ 𝒜 ∧ insert a s ∈ 𝒜) |
CompHausLike.pullback._proof_2 | Mathlib.Topology.Category.CompHausLike.Limits | ∀ {P : TopCat → Prop} {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B),
T2Space
{ x // x ∈ {xy | (CategoryTheory.ConcreteCategory.hom f) xy.1 = (CategoryTheory.ConcreteCategory.hom g) xy.2} } |
TopModuleCat.instHasForget₂ContinuousLinearMapIdCarrierModuleCatLinearMap._proof_1 | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ (R : Type u_2) [inst : Ring R] [inst_1 : TopologicalSpace R] (X : TopModuleCat R),
ModuleCat.ofHom ↑(TopModuleCat.Hom.hom (CategoryTheory.CategoryStruct.id X)) =
CategoryTheory.CategoryStruct.id (ModuleCat.of R ↑X.toModuleCat) |
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.getKey?_modify_self._simp_1_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true) |
CategoryTheory.ShortComplex.instModuleHom._proof_6 | Mathlib.Algebra.Homology.ShortComplex.Linear | ∀ {R : Type u_3} {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {S₁ S₂ : CategoryTheory.ShortComplex C}
(a : R), a • 0 = 0 |
_private.Mathlib.Dynamics.Ergodic.AddCircle.0.AddCircle.ae_empty_or_univ_of_forall_vadd_ae_eq_self._simp_1_1 | Mathlib.Dynamics.Ergodic.AddCircle | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c |
descPochhammer_map | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ {R : Type u} [inst : Ring R] {T : Type v} [inst_1 : Ring T] (f : R →+* T) (n : ℕ),
Polynomial.map f (descPochhammer R n) = descPochhammer T n |
matrixEquivTensor._proof_5 | Mathlib.RingTheory.MatrixAlgebra | ∀ (n : Type u_2) (R : Type u_3) (A : Type u_1) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Fintype n] [inst_4 : DecidableEq n] (r : R),
(↑↑(MatrixEquivTensor.toFunAlgHom n R A).toRingHom).toFun ((algebraMap R (TensorProduct R A (Matrix n n R))) r) =
(algebraMap R (Matrix n n A)) r |
Polynomial.degree_ne_bot | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.degree ≠ ⊥ ↔ p ≠ 0 |
bernoulliFun_one | Mathlib.NumberTheory.ZetaValues | ∀ (x : ℝ), bernoulliFun 1 x = x - 1 / 2 |
AddMonoidHom.op._proof_6 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_2} {N : Type u_1} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : Mᵃᵒᵖ →+ Nᵃᵒᵖ) (x y : M),
AddOpposite.unop ((⇑f ∘ AddOpposite.op) (x + y)) =
AddOpposite.unop
{ unop' := (AddOpposite.unop ∘ ⇑f ∘ AddOpposite.op) x + (AddOpposite.unop ∘ ⇑f ∘ AddOpposite.op) y } |
DFinsupp.lsum | Mathlib.LinearAlgebra.DFinsupp | {ι : Type u_1} →
{R : Type u_3} →
(S : Type u_4) →
{M : ι → Type u_5} →
{N : Type u_6} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M i)] →
[inst_2 : (i : ι) → Module R (M i)] →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R N] →
[DecidableEq ι] →
[inst_6 : Semiring S] →
[inst_7 : Module S N] →
[inst_8 : SMulCommClass R S N] → ((i : ι) → M i →ₗ[R] N) ≃ₗ[S] (Π₀ (i : ι), M i) →ₗ[R] N |
Finset.diag_eq_filter | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {s : Finset α} [inst : DecidableEq α], s.diag = {a ∈ s ×ˢ s | a.1 = a.2} |
Lean.MonadLog.casesOn | Lean.Log | {m : Type → Type} →
{motive : Lean.MonadLog m → Sort u} →
(t : Lean.MonadLog m) →
([toMonadFileMap : Lean.MonadFileMap m] →
(getRef : m Lean.Syntax) →
(getFileName : m String) →
(hasErrors : m Bool) →
(logMessage : Lean.Message → m Unit) →
motive
{ toMonadFileMap := toMonadFileMap, getRef := getRef, getFileName := getFileName,
hasErrors := hasErrors, logMessage := logMessage }) →
motive t |
NumberField.FinitePlace.mk_eq_iff._simp_1 | Mathlib.NumberTheory.NumberField.FinitePlaces | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
{v₁ v₂ : IsDedekindDomain.HeightOneSpectrum (NumberField.RingOfIntegers K)},
(NumberField.FinitePlace.mk v₁ = NumberField.FinitePlace.mk v₂) = (v₁ = v₂) |
Array.map_set._proof_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_2} {β : Type u_1} {f : α → β} {xs : Array α} {i : ℕ} {h : i < xs.size}, i < (Array.map f xs).size |
Aesop.Script.DynStructureResult.mk.sizeOf_spec | Aesop.Script.StructureDynamic | ∀ (script : List Aesop.Script.Step) (postState : Lean.Meta.SavedState),
sizeOf { script := script, postState := postState } = 1 + sizeOf script + sizeOf postState |
CategoryTheory.Over.iteratedSliceForwardNaturalityIso_hom_app | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (p : f ⟶ g)
(X_1 : CategoryTheory.Over f),
(CategoryTheory.Over.iteratedSliceForwardNaturalityIso p).hom.app X_1 =
CategoryTheory.CategoryStruct.id ((CategoryTheory.Over.map p.left).obj (CategoryTheory.Over.mk X_1.hom.left)) |
cantorToBinary.eq_1 | Mathlib.Topology.Instances.CantorSet | ∀ (x : ℝ), cantorToBinary x = Stream'.map (fun x => if x ∈ Set.Icc 0 (1 / 3) then false else true) (cantorSequence x) |
Subgroup.comap.eq_1 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] {N : Type u_7} [inst_1 : Group N] (f : G →* N) (H : Subgroup N),
Subgroup.comap f H = { carrier := ⇑f ⁻¹' ↑H, mul_mem' := ⋯, one_mem' := ⋯, inv_mem' := ⋯ } |
_private.Lean.Elab.Tactic.Omega.Frontend.0.Lean.Elab.Tactic.Omega.succ?._sparseCasesOn_2 | Lean.Elab.Tactic.Omega.Frontend | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
AlgHom.op._proof_3 | Mathlib.Algebra.Algebra.Opposite | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (r : R),
(↑↑(RingHom.op f.toRingHom)).toFun ((algebraMap R Aᵐᵒᵖ) r) = (algebraMap R Bᵐᵒᵖ) r |
_private.Init.Data.SInt.Lemmas.0.ISize.le_iff_lt_or_eq._proof_1_4 | Init.Data.SInt.Lemmas | ∀ {a b : ISize}, ¬(a.toInt ≤ b.toInt ↔ a.toInt < b.toInt ∨ a.toInt = b.toInt) → False |
_private.Mathlib.LinearAlgebra.SymmetricAlgebra.Basis.0.SymmetricAlgebra.rank_eq.match_1_1 | Mathlib.LinearAlgebra.SymmetricAlgebra.Basis | ∀ {R : Type u_2} {M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : Nonempty ((I : Type u_1) × Module.Basis I R M) → Prop) (x : Nonempty ((I : Type u_1) × Module.Basis I R M)),
(∀ (κ : Type u_1) (b : Module.Basis κ R M), motive ⋯) → motive x |
DirectLimit.instAddCommGroupWithOneOfAddMonoidHomClass._proof_6 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_2}
[inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)] [inst_2 : (i : ι) → AddCommGroupWithOne (G i)]
[∀ (i j : ι) (h : i ≤ j), AddMonoidHomClass (T h) (G i) (G j)] (i j : ι) (h : i ≤ j), AddHomClass (T h) (G i) (G j) |
_private.Mathlib.Algebra.Order.GroupWithZero.WithZero.0.instPosMulMonoWithZeroOfMulLeftMono.match_1 | Mathlib.Algebra.Order.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : Preorder α] (motive : (x : WithZero α) → 0 ≤ x → (x x_1 : WithZero α) → x ≤ x_1 → Prop)
(x : WithZero α) (x_1 : 0 ≤ x) (x_2 x_3 : WithZero α) (x_4 : x_2 ≤ x_3),
(∀ (x : 0 ≤ 0) (a b : WithZero α) (x_5 : a ≤ b), motive none x a b x_5) →
(∀ (x : α) (x_5 : 0 ≤ ↑x) (x_6 : WithZero α) (x_7 : 0 ≤ x_6), motive (some x) x_5 none x_6 x_7) →
(∀ (x : α) (x_5 : 0 ≤ ↑x) (a : α) (h : ↑a ≤ 0), motive (some x) x_5 (some a) none h) →
(∀ (x : α) (hx : 0 ≤ ↑x) (a b : α) (h : ↑a ≤ ↑b), motive (some x) hx (some a) (some b) h) →
motive x x_1 x_2 x_3 x_4 |
instAddGroupUniformOnFun.eq_1 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : AddGroup β], instAddGroupUniformOnFun = Pi.addGroup |
IsNonarchimedeanLocalField.valueGroupWithZeroIsoInt._proof_1 | Mathlib.NumberTheory.LocalField.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : ValuativeRel K] [inst_2 : TopologicalSpace K]
[IsNonarchimedeanLocalField K], Nonempty (ValuativeRel.ValueGroupWithZero K ≃*o WithZero (Multiplicative ℤ)) |
_private.Lean.Compiler.IR.LLVMBindings.0.LLVM.BasicBlock.mk | Lean.Compiler.IR.LLVMBindings | {Context : Sort u_1} → {ctx : Context} → USize → LLVM.BasicBlock ctx |
Ideal.isPrimary_finset_inf | Mathlib.RingTheory.Ideal.IsPrimary | ∀ {R : Type u_1} [inst : CommSemiring R] {ι : Type u_3} {s : Finset ι} {f : ι → Ideal R} {i : ι},
i ∈ s →
(∀ ⦃y : ι⦄, y ∈ s → (f y).IsPrimary) → (∀ ⦃y : ι⦄, y ∈ s → (f y).radical = (f i).radical) → (s.inf f).IsPrimary |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.