name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.Tactic.SuccessIfFailWithMsg.0.Mathlib.Tactic.successIfFailWithMessage.match_4 | Mathlib.Tactic.SuccessIfFailWithMsg | (motive : Option Lean.Syntax → Sort u_1) →
(ref : Option Lean.Syntax) →
((ref : Lean.Syntax) → motive (some ref)) → ((x : Option Lean.Syntax) → motive x) → motive ref |
_private.Mathlib.Analysis.CStarAlgebra.ApproximateUnit.0.CFC.monotoneOn_one_sub_one_add_inv_real._proof_1_1 | Mathlib.Analysis.CStarAlgebra.ApproximateUnit | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A] ⦃a : A⦄,
0 ≤ a → ∀ ⦃x : ℝ⦄, x ∈ quasispectrum ℝ a → 0 ≤ x |
RootPairing.restrictScalars._proof_1 | Mathlib.LinearAlgebra.RootSystem.BaseChange | ∀ {ι : Type u_1} {L : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Field L] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : Module L M] [inst_4 : Module L N] (P : RootPairing ι L M N) (K : Type u_5)
[inst_5 : Field K] [inst_6 : Algebra K L] [P.IsCrystallographic], P.IsValuedIn K |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.guessReorder.decomposePerm._proof_1 | Mathlib.Tactic.Translate.Reorder | ∀ {n : ℕ},
∀ i ∈ 0...n,
∀
(r :
MProd (Option (List { l // 2 ≤ l.length })) (MProd (Vector (Option (Fin n)) n) (List { l // 2 ≤ l.length }))),
i < n |
Batteries.RBSet.find?.eq_1 | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} (t : Batteries.RBSet α cmp) (x : α),
t.find? x = Batteries.RBNode.find? (cmp x) ↑t |
_private.Mathlib.Probability.ProductMeasure.0.MeasureTheory.Measure.infinitePi_pi_univ._simp_1_1 | Mathlib.Probability.ProductMeasure | ∀ {α : Type u}, Set.univ.Countable = Countable α |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_ediv_toInt_nonpos_of_nonpos_of_nonneg._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)}, x.toInt ≤ 0 → 0 ≤ y.toInt → ¬x.toInt = 0 → ¬y.toInt = 0 → ¬x.toInt < 0 → False |
Submonoid.powers._proof_2 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : Monoid M], MonoidHomClass (Multiplicative ℕ →* M) (Multiplicative ℕ) M |
SSet.Subcomplex.image_preimage_le._simp_1 | Mathlib.AlgebraicTopology.SimplicialSet.Subcomplex | ∀ {X Y : SSet} (B : X.Subcomplex) (f : Y ⟶ X), ((B.preimage f).image f ≤ B) = True |
Algebra.Presentation.mk.inj | Mathlib.RingTheory.Extension.Presentation.Basic | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} {inst : CommRing R} {inst_1 : CommRing S} {inst_2 : Algebra R S}
{toGenerators : Algebra.Generators R S ι} {relation : σ → toGenerators.Ring}
{span_range_relation_eq_ker : Ideal.span (Set.range relation) = toGenerators.ker}
{toGenerators_1 : Algebra.Generators R S ι} {relation_1 : σ → toGenerators_1.Ring}
{span_range_relation_eq_ker_1 : Ideal.span (Set.range relation_1) = toGenerators_1.ker},
{ toGenerators := toGenerators, relation := relation, span_range_relation_eq_ker := span_range_relation_eq_ker } =
{ toGenerators := toGenerators_1, relation := relation_1,
span_range_relation_eq_ker := span_range_relation_eq_ker_1 } →
toGenerators = toGenerators_1 ∧ relation = relation_1 |
selfAdjoint.unitarySelfAddISMul._proof_5 | Mathlib.Analysis.CStarAlgebra.Unitary.Span | ∀ {A : Type u_1} [inst : CStarAlgebra A], SMulCommClass ℝ A A |
Lean.Expr.isHEq | Lean.Util.Recognizers | Lean.Expr → Bool |
Filter.IsBoundedUnder.bddAbove_range_of_cofinite | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] [IsDirectedOrder β] {f : α → β},
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) Filter.cofinite f → BddAbove (Set.range f) |
Lean.Meta.Grind.Order.ProofInfo.recOn | Lean.Meta.Tactic.Grind.Order.Types | {motive : Lean.Meta.Grind.Order.ProofInfo → Sort u} →
(t : Lean.Meta.Grind.Order.ProofInfo) →
((w : Lean.Meta.Grind.Order.NodeId) →
(k : Lean.Meta.Grind.Order.Weight) → (proof : Lean.Expr) → motive { w := w, k := k, proof := proof }) →
motive t |
String.head_toList | Init.Data.String.Basic | ∀ {b : String} {h : b.toList ≠ []}, b.toList.head h = b.toByteArray.utf8DecodeChar 0 ⋯ |
lt_map_inv_iff | Mathlib.Order.Hom.Basic | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : EquivLike F α β]
[OrderIsoClass F α β] (f : F) {a : α} {b : β}, a < EquivLike.inv f b ↔ f a < b |
Lean.Elab.Tactic.filterSuggestionsAndLocalsFromGrindConfig | Lean.Elab.Tactic.Grind.Main | Lean.TSyntax `Lean.Parser.Tactic.optConfig → Lean.TSyntax `Lean.Parser.Tactic.optConfig |
_private.Init.Data.String.Basic.0.String.startPos_eq_endPos_iff._simp_1_1 | Init.Data.String.Basic | ∀ {s : String}, (s = "") = (s.utf8ByteSize = 0) |
OrderDual.isOrderedAddCancelMonoid | Mathlib.Algebra.Order.Monoid.OrderDual | ∀ {α : Type u} [inst : AddCommMonoid α] [inst_1 : Preorder α] [IsOrderedCancelAddMonoid α], IsOrderedCancelAddMonoid αᵒᵈ |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.analyzeAppStagedCore.match_8 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | (motive : Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State → Sort u_1) →
(__discr : Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State) →
((bottomUps higherOrders funBinders provideds : Array Bool) →
(namedArgs : Array Lean.Name) →
motive
{ bottomUps := bottomUps, higherOrders := higherOrders, funBinders := funBinders, provideds := provideds,
namedArgs := namedArgs }) →
motive __discr |
SimpleGraph.neighborFinset_eq_filter | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : Fintype V] {v : V} [inst_1 : DecidableRel G.Adj],
G.neighborFinset v = {w | G.Adj v w} |
Std.Rio.pairwise_toList_ne | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rio α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.Least? α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLT α] [Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst_7 : Std.Rxo.IsAlwaysFinite α], List.Pairwise (fun a b => a ≠ b) r.toList |
IsModuleTopology.topologicalAddGroup | Mathlib.Topology.Algebra.Module.ModuleTopology | ∀ (R : Type u_1) [τR : TopologicalSpace R] [inst : Semiring R] (C : Type u_6) [inst_1 : AddCommGroup C]
[inst_2 : Module R C] [inst_3 : TopologicalSpace C] [IsModuleTopology R C], IsTopologicalAddGroup C |
AList.insertRec._proof_3 | Mathlib.Data.List.AList | ∀ {α : Type u_1} {β : α → Type u_2} (c : Sigma β) (l : List (Sigma β)) (h : (c :: l).NodupKeys),
c.fst ∉ { entries := l, nodupKeys := ⋯ }.entries.keys |
AddAction.IsQuasiPreprimitive.casesOn | Mathlib.GroupTheory.GroupAction.Primitive | {G : Type u_1} →
{X : Type u_2} →
[inst : AddGroup G] →
[inst_1 : AddAction G X] →
{motive : AddAction.IsQuasiPreprimitive G X → Sort u} →
(t : AddAction.IsQuasiPreprimitive G X) →
([toIsPretransitive : AddAction.IsPretransitive G X] →
(isPretransitive_of_normal :
∀ {N : AddSubgroup G} [N.Normal],
AddAction.fixedPoints (↥N) X ≠ Set.univ → AddAction.IsPretransitive (↥N) X) →
motive ⋯) →
motive t |
Finset.sum_induction_nonempty | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {s : Finset ι} {M : Type u_7} [inst : AddCommMonoid M] (f : ι → M) (p : M → Prop),
(∀ (a b : M), p a → p b → p (a + b)) → s.Nonempty → (∀ x ∈ s, p (f x)) → p (∑ x ∈ s, f x) |
ZFSet.powerset.match_5 | Mathlib.SetTheory.ZFC.Basic | ∀ (α : Type u_1) (A : α → PSet.{u_1}) (α_1 : Type u_1) (B : α_1 → PSet.{u_1}) (q : Set (PSet.mk α_1 B).Type)
(motive : ↑{a | ∃ b ∈ q, (A a).Equiv (B b)} → Prop) (x : ↑{a | ∃ b ∈ q, (A a).Equiv (B b)}),
(∀ (val : (PSet.mk α A).Type) (b : (PSet.mk α_1 B).Type) (qb : b ∈ q) (ab : (A val).Equiv (B b)), motive ⟨val, ⋯⟩) →
motive x |
Lean.Parser.ParserAttributeHook.recOn | Lean.Parser.Extension | {motive : Lean.Parser.ParserAttributeHook → Sort u} →
(t : Lean.Parser.ParserAttributeHook) →
((postAdd : Lean.Name → Lean.Name → Bool → Lean.AttrM Unit) → motive { postAdd := postAdd }) → motive t |
Lean.Elab.CompletionInfo.dotId.sizeOf_spec | Lean.Elab.InfoTree.Types | ∀ (stx : Lean.Syntax) (id : Lean.Name) (lctx : Lean.LocalContext) (expectedType? : Option Lean.Expr),
sizeOf (Lean.Elab.CompletionInfo.dotId stx id lctx expectedType?) =
1 + sizeOf stx + sizeOf id + sizeOf lctx + sizeOf expectedType? |
Lean.PrettyPrinter.Formatter.charLitNoAntiquot.formatter | Lean.PrettyPrinter.Formatter | Lean.PrettyPrinter.Formatter |
Lean.Elab.Tactic.BVDecide.LRAT.trim.State._sizeOf_1 | Lean.Elab.Tactic.BVDecide.LRAT.Trim | Lean.Elab.Tactic.BVDecide.LRAT.trim.State → ℕ |
TopologicalSpace.rec | Mathlib.Topology.Defs.Basic | {X : Type u} →
{motive : TopologicalSpace X → Sort u_1} →
((IsOpen : Set X → Prop) →
(isOpen_univ : IsOpen Set.univ) →
(isOpen_inter : ∀ (s t : Set X), IsOpen s → IsOpen t → IsOpen (s ∩ t)) →
(isOpen_sUnion : ∀ (s : Set (Set X)), (∀ t ∈ s, IsOpen t) → IsOpen (⋃₀ s)) →
motive
{ IsOpen := IsOpen, isOpen_univ := isOpen_univ, isOpen_inter := isOpen_inter,
isOpen_sUnion := isOpen_sUnion }) →
(t : TopologicalSpace X) → motive t |
NumberField.InfinitePlace.Completion.bijective_extensionEmbeddingOfIsReal | Mathlib.NumberTheory.NumberField.InfinitePlace.Completion | ∀ {K : Type u_1} [inst : Field K] {v : NumberField.InfinitePlace K} (hv : v.IsReal),
Function.Bijective ⇑(NumberField.InfinitePlace.Completion.extensionEmbeddingOfIsReal hv) |
Lean.Compiler.LCNF.LCtx.eraseLetDecl | Lean.Compiler.LCNF.LCtx | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.LCtx → Lean.Compiler.LCNF.LetDecl pu → Lean.Compiler.LCNF.LCtx |
Metric.IsCover.subset_iUnion_closedBall | Mathlib.Topology.MetricSpace.Cover | ∀ {X : Type u_1} [inst : PseudoMetricSpace X] {ε : NNReal} {s N : Set X},
Metric.IsCover ε s N → s ⊆ ⋃ y ∈ N, Metric.closedBall y ↑ε |
_private.Lean.Meta.Tactic.Subst.0.Lean.Meta.introSubstEq.match_7 | Lean.Meta.Tactic.Subst | (motive : DoResultPR (Lean.Meta.FVarSubst × Lean.MVarId) (Lean.Meta.FVarSubst × Lean.MVarId) PUnit.{1} → Sort u_1) →
(r : DoResultPR (Lean.Meta.FVarSubst × Lean.MVarId) (Lean.Meta.FVarSubst × Lean.MVarId) PUnit.{1}) →
((a : Lean.Meta.FVarSubst × Lean.MVarId) → (u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : Lean.Meta.FVarSubst × Lean.MVarId) → (u : PUnit.{1}) → motive (DoResultPR.return b u)) → motive r |
Nat.Linear.Poly.norm.go.eq_1 | Init.Data.Nat.Linear | ∀ (r : Nat.Linear.Poly), Nat.Linear.Poly.norm.go [] r = r |
FP.RMode.recOn | Mathlib.Data.FP.Basic | {motive : FP.RMode → Sort u} → (t : FP.RMode) → motive FP.RMode.NE → motive t |
Lean.Elab.Command.MacroExpandedSnapshot.isFatal._inherited_default | Lean.Elab.Command | Bool |
_private.Mathlib.NumberTheory.Bernoulli.0.bernoulli'_eq_bernoulli._simp_1_4 | Mathlib.NumberTheory.Bernoulli | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (m n : ℕ), (a ^ m) ^ n = a ^ (m * n) |
BoxIntegral.integral_sub | Mathlib.Analysis.BoxIntegral.Basic | ∀ {ι : Type u} {E : Type v} {F : Type w} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {I : BoxIntegral.Box ι} [inst_4 : Fintype ι]
{l : BoxIntegral.IntegrationParams} {f g : (ι → ℝ) → E} {vol : BoxIntegral.BoxAdditiveMap ι (E →L[ℝ] F) ⊤},
BoxIntegral.Integrable I l f vol →
BoxIntegral.Integrable I l g vol →
BoxIntegral.integral I l (f - g) vol = BoxIntegral.integral I l f vol - BoxIntegral.integral I l g vol |
_private.Mathlib.Data.List.Duplicate.0.List._aux_Mathlib_Data_List_Duplicate___unexpand_List_Duplicate_1 | Mathlib.Data.List.Duplicate | Lean.PrettyPrinter.Unexpander |
ContinuousLinearMap.flip_zero | 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 σ₂₃] [inst_10 : RingHomIsometric σ₁₃], ContinuousLinearMap.flip 0 = 0 |
LinearMap.instDistribMulAction._proof_2 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R : Type u_1} {R₂ : Type u_2} {S : Type u_5} {M : Type u_3} {M₂ : Type u_4} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M]
[inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂} [inst_6 : Monoid S] [inst_7 : DistribMulAction S M₂]
[inst_8 : SMulCommClass R₂ S M₂] (x : M →ₛₗ[σ₁₂] M₂), 1 • x = x |
_private.Mathlib.CategoryTheory.Limits.Shapes.Biproducts.0.CategoryTheory.Limits.instHasBiproductSigmaFstSndOfBiproduct.match_1 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {ι : Type u_1} (f : ι → Type u_2) (motive : (i : ι) × f i → Prop) (x : (i : ι) × f i),
(∀ (j' : ι) (y : f j'), motive ⟨j', y⟩) → motive x |
CategoryTheory.Subgroupoid.mem_top_objs | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (c : C), c ∈ ⊤.objs |
MeasurableMul | Mathlib.MeasureTheory.Group.Arithmetic | (M : Type u_2) → [MeasurableSpace M] → [Mul M] → Prop |
LinearMap.ext_on | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Semiring R₂] [inst_4 : AddCommMonoid M₂] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
{s : Set M} {f g : M →ₛₗ[σ₁₂] M₂}, Submodule.span R s = ⊤ → Set.EqOn (⇑f) (⇑g) s → f = g |
_private.Mathlib.Logic.Equiv.Basic.0.Equiv.swap_eq_refl_iff._proof_1_1 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} [inst : DecidableEq α] {x y : α}, Equiv.swap x y = Equiv.refl α → (Equiv.refl α) x = (Equiv.refl α) y |
_private.Mathlib.Probability.Process.Stopping.0.MeasureTheory.memLp_stoppedValue._simp_1_1 | Mathlib.Probability.Process.Stopping | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y |
Aesop.RappData.successProbability | Aesop.Tree.Data | {Goal MVarCluster : Type} → Aesop.RappData Goal MVarCluster → Aesop.Percent |
Holor.instAddMonoid | Mathlib.Data.Holor | {α : Type} → {ds : List ℕ} → [AddMonoid α] → AddMonoid (Holor α ds) |
_private.Mathlib.Analysis.FunctionalSpaces.SobolevInequality.0.MeasureTheory.eLpNorm_le_eLpNorm_fderiv_of_eq_inner._simp_1_14 | Mathlib.Analysis.FunctionalSpaces.SobolevInequality | ∀ (x : ENNReal) (y z : ℝ), (x ^ y) ^ z = x ^ (y * z) |
FDerivMeasurableAux.B | Mathlib.Analysis.Calculus.FDeriv.Measurable | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{F : Type u_3} →
[inst_3 : NormedAddCommGroup F] → [inst_4 : NormedSpace 𝕜 F] → (E → F) → Set (E →L[𝕜] F) → ℝ → ℝ → ℝ → Set E |
OmegaCompletePartialOrder.Chain.map_comp | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
(c : OmegaCompletePartialOrder.Chain α) {f : α →o β} (g : β →o γ), (c.map f).map g = c.map (g.comp f) |
Std.DTreeMap.Raw.minKey!_alter_eq_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] [inst_1 : Inhabited α],
t.WF →
∀ {k : α} {f : Option (β k) → Option (β k)},
(t.alter k f).isEmpty = false →
((t.alter k f).minKey! = k ↔ (f (t.get? k)).isSome = true ∧ ∀ k' ∈ t, (cmp k k').isLE = true) |
one_lt_iff_ne_one | Mathlib.Algebra.Order.Monoid.Canonical.Defs | ∀ {α : Type u} [inst : MulOneClass α] [inst_1 : PartialOrder α] [CanonicallyOrderedMul α] {a : α}, 1 < a ↔ a ≠ 1 |
CauSeq.le_total | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] (f g : CauSeq α abs),
f ≤ g ∨ g ≤ f |
MeasureTheory.tendstoInMeasure_of_tendsto_eLpNorm_top | Mathlib.MeasureTheory.Function.ConvergenceInMeasure | ∀ {α : Type u_1} {ι : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {E : Type u_5}
[inst : SeminormedAddCommGroup E] {f : ι → α → E} {g : α → E} {l : Filter ι},
Filter.Tendsto (fun n => MeasureTheory.eLpNorm (f n - g) ⊤ μ) l (nhds 0) → MeasureTheory.TendstoInMeasure μ f l g |
Lean.mkCIdentFromRef | Init.Meta.Defs | {m : Type → Type} → [Monad m] → [Lean.MonadRef m] → Lean.Name → optParam Bool false → m Lean.Syntax |
MeasureTheory.Measure.completion._proof_1 | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {α : Type u_1} {x : MeasurableSpace α} (μ : MeasureTheory.Measure α), μ.trim ≤ μ.toOuterMeasure |
HomotopicalAlgebra.PathObject.recOn | Mathlib.AlgebraicTopology.ModelCategory.PathObject | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] →
{A : C} →
{motive : HomotopicalAlgebra.PathObject A → Sort u_1} →
(t : HomotopicalAlgebra.PathObject A) →
((toPrepathObject : HomotopicalAlgebra.PrepathObject A) →
(weakEquivalence_ι : HomotopicalAlgebra.WeakEquivalence toPrepathObject.ι) →
motive { toPrepathObject := toPrepathObject, weakEquivalence_ι := weakEquivalence_ι }) →
motive t |
Subsemiring.center.smulCommClass_right | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R' : Type u_1} [inst : Semiring R'], SMulCommClass R' (↥(Subsemiring.center R')) R' |
IsCompact.exists_bound_of_continuousOn' | Mathlib.Analysis.Normed.Group.Bounded | ∀ {α : Type u_1} {E : Type u_2} [inst : SeminormedGroup E] [inst_1 : TopologicalSpace α] {s : Set α},
IsCompact s → ∀ {f : α → E}, ContinuousOn f s → ∃ C, ∀ x ∈ s, ‖f x‖ ≤ C |
NonemptyInterval.instPartialOrderLex | Mathlib.Order.Interval.Lex | {α : Type u_1} → [inst : PartialOrder α] → PartialOrder (Lex (NonemptyInterval α)) |
CategoryTheory.Quotient.comp_natTransLift | Mathlib.CategoryTheory.Quotient | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (r : HomRel C) {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {F G H : CategoryTheory.Functor (CategoryTheory.Quotient r) D}
(τ : (CategoryTheory.Quotient.functor r).comp F ⟶ (CategoryTheory.Quotient.functor r).comp G)
(τ' : (CategoryTheory.Quotient.functor r).comp G ⟶ (CategoryTheory.Quotient.functor r).comp H),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Quotient.natTransLift r τ)
(CategoryTheory.Quotient.natTransLift r τ') =
CategoryTheory.Quotient.natTransLift r (CategoryTheory.CategoryStruct.comp τ τ') |
Algebra.Extension.h1Cotangentι_apply | Mathlib.RingTheory.Extension.Cotangent.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Algebra.Extension R S}
(self : ↥P.cotangentComplex.ker), Algebra.Extension.h1Cotangentι self = ↑self |
_private.Mathlib.Data.Finset.Pi.0.Finset.pi_nonempty._simp_1_1 | Mathlib.Data.Finset.Pi | ∀ {α : Sort u} {b : α → Sort v} {p : (x : α) → b x → Prop}, (∀ (x : α), ∃ y, p x y) = ∃ f, ∀ (x : α), p x (f x) |
RCLike.ofReal_re_ax | Mathlib.Analysis.RCLike.Basic | ∀ {K : semiOutParam (Type u_1)} [self : RCLike K] (r : ℝ), RCLike.re ((algebraMap ℝ K) r) = r |
UInt64.reduceDiv._regBuiltin.UInt64.reduceDiv.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.4002762760._hygCtx._hyg.99 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit |
SSet.Subcomplex.image_comp | Mathlib.AlgebraicTopology.SimplicialSet.Subcomplex | ∀ {X Y : SSet} (A : X.Subcomplex) (f : X ⟶ Y) {Z : SSet} (g : Y ⟶ Z),
A.image (CategoryTheory.CategoryStruct.comp f g) = (A.image f).image g |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.idCompletionCore._sparseCasesOn_1 | Lean.Server.Completion.CompletionCollectors | {motive : Lean.SourceInfo → Sort u} →
(t : Lean.SourceInfo) →
((leading : Substring.Raw) →
(pos : String.Pos.Raw) →
(trailing : Substring.Raw) →
(endPos : String.Pos.Raw) → motive (Lean.SourceInfo.original leading pos trailing endPos)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
_private.Mathlib.Data.List.Induction.0.List.reverseRec_concat._proof_1_61 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (x : α) (xs : List α) (head : α) (tail : List α), head :: tail = xs → ¬xs ++ [x].dropLast = [] |
Mathlib.Tactic.RingNF.instBEqConfig.beq | Mathlib.Tactic.Ring.RingNF | Mathlib.Tactic.RingNF.Config → Mathlib.Tactic.RingNF.Config → Bool |
_private.Mathlib.Algebra.Polynomial.Div.0.Polynomial.rootMultiplicity_eq_zero_iff._simp_1_3 | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} {a : R} [inst : CommRing R] {p : Polynomial R}, (Polynomial.X - Polynomial.C a ∣ p) = p.IsRoot a |
MulSemiringActionHom.map_one' | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {R : Type u_10} [inst_2 : Semiring R]
[inst_3 : MulSemiringAction M R] {S : Type u_12} [inst_4 : Semiring S] [inst_5 : MulSemiringAction N S]
(self : R →ₑ+*[φ] S), self.toFun 1 = 1 |
HasCompactSupport.convolutionExists_left_of_continuous_right | Mathlib.Analysis.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {E : Type uE} {E' : Type uE'} {F : Type uF} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup E'] [inst_2 : NormedAddCommGroup F] {f : G → E} {g : G → E'}
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : NormedSpace 𝕜 F]
(L : E →L[𝕜] E' →L[𝕜] F) [inst_7 : MeasurableSpace G] {μ : MeasureTheory.Measure G} [inst_8 : AddGroup G]
[inst_9 : TopologicalSpace G] [IsTopologicalAddGroup G] [BorelSpace G],
HasCompactSupport f → MeasureTheory.LocallyIntegrable f μ → Continuous g → MeasureTheory.ConvolutionExists f g L μ |
WeakDual.CharacterSpace.equivAlgHom_symm_coe | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedRing A] [inst_2 : CompleteSpace A]
[inst_3 : NormedAlgebra 𝕜 A] (f : A →ₐ[𝕜] 𝕜), ⇑(WeakDual.CharacterSpace.equivAlgHom.symm f) = ⇑f |
Simps.ProjectionRule.erase.injEq | Mathlib.Tactic.Simps.Basic | ∀ (a : Lean.Name) (a_1 : Lean.Syntax) (a_2 : Lean.Name) (a_3 : Lean.Syntax),
(Simps.ProjectionRule.erase a a_1 = Simps.ProjectionRule.erase a_2 a_3) = (a = a_2 ∧ a_1 = a_3) |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.withInductiveLocalDecls.loop._unary | Lean.Elab.MutualInductive | {α : Type} →
Array Lean.Elab.Command.PreElabHeaderResult →
(Array Lean.Expr → Array Lean.Expr → Lean.Elab.TermElabM α) →
Array Lean.Expr → (_ : ℕ) ×' Array Lean.Expr → Lean.Elab.TermElabM α |
mem_residual_iff | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X},
s ∈ residual X ↔ ∃ S, (∀ t ∈ S, IsOpen t) ∧ (∀ t ∈ S, Dense t) ∧ S.Countable ∧ ⋂₀ S ⊆ s |
Submonoid.map_coe_toMonoidHom | 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) (S : Submonoid M), Submonoid.map (↑f) S = Submonoid.map f S |
CategoryTheory.Equivalence.functor_map_ε_inverse_comp_counit_app | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D] (e : C ≌ D)
[inst_4 : e.functor.Monoidal] [inst_5 : e.inverse.Monoidal] [e.IsMonoidal],
CategoryTheory.CategoryStruct.comp (e.functor.map (CategoryTheory.Functor.LaxMonoidal.ε e.inverse))
(e.counit.app (CategoryTheory.MonoidalCategoryStruct.tensorUnit D)) =
CategoryTheory.Functor.OplaxMonoidal.η e.functor |
lowerSemicontinuous_biSup | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {ι : Sort u_4} {δ : Type u_5} [inst_1 : CompleteLinearOrder δ]
{p : ι → Prop} {f : (i : ι) → p i → α → δ},
(∀ (i : ι) (hi : p i), LowerSemicontinuous (f i hi)) → LowerSemicontinuous fun x' => ⨆ i, ⨆ (hi : p i), f i hi x' |
_private.Mathlib.Order.SuccPred.WithBot.0.WithBot.succ_eq_succ.match_1_1 | Mathlib.Order.SuccPred.WithBot | ∀ {α : Type u_1} (motive : WithBot α → Prop) (x : WithBot α),
(∀ (a : Unit), motive none) → (∀ (a : α), motive (some a)) → motive x |
Metric.Snowflaking.dist_ofSnowflaking_ofSnowflaking | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : PseudoMetricSpace X]
(x y : Metric.Snowflaking X α hα₀ hα₁),
dist (Metric.Snowflaking.ofSnowflaking x) (Metric.Snowflaking.ofSnowflaking y) = dist x y ^ α⁻¹ |
SimpleGraph.Partition.partOfVertex._proof_1 | Mathlib.Combinatorics.SimpleGraph.Partition | ∀ {V : Type u_1} {G : SimpleGraph V} (P : G.Partition) (v : V), ∃! b, b ∈ P.parts ∧ v ∈ b |
_private.Mathlib.Data.Sigma.Basic.0.Sigma.eq.match_1_1 | Mathlib.Data.Sigma.Basic | ∀ {α : Type u_1} {β : α → Type u_2}
(motive : (x x_1 : (a : α) × β a) → (x_2 : x.fst = x_1.fst) → Eq.recOn x_2 x.snd = x_1.snd → Prop)
(x x_1 : (a : α) × β a) (x_2 : x.fst = x_1.fst) (x_3 : Eq.recOn x_2 x.snd = x_1.snd),
(∀ (fst : α) (snd : β fst), motive ⟨fst, snd⟩ ⟨fst, snd⟩ ⋯ ⋯) → motive x x_1 x_2 x_3 |
Lean.instBEqDeclaration.beq | Lean.Declaration | Lean.Declaration → Lean.Declaration → Bool |
HasDerivAt.const_mul | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝔸 : Type u_3} [inst_1 : NormedRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {d : 𝕜 → 𝔸} {d' : 𝔸} (c : 𝔸),
HasDerivAt d d' x → HasDerivAt (fun y => c * d y) (c * d') x |
AlgebraicGeometry.Scheme.IdealSheafData.recOn | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | {X : AlgebraicGeometry.Scheme} →
{motive : X.IdealSheafData → Sort u_1} →
(t : X.IdealSheafData) →
((ideal : (U : ↑X.affineOpens) → Ideal ↑(X.presheaf.obj (Opposite.op ↑U))) →
(map_ideal_basicOpen :
∀ (U : ↑X.affineOpens) (f : ↑(X.presheaf.obj (Opposite.op ↑U))),
Ideal.map (CommRingCat.Hom.hom (X.presheaf.map (CategoryTheory.homOfLE ⋯).op)) (ideal U) =
ideal (X.affineBasicOpen f)) →
(supportSet : Set ↥X) →
(supportSet_eq_iInter_zeroLocus : supportSet = ⋂ U, X.zeroLocus ↑(ideal U)) →
motive
{ ideal := ideal, map_ideal_basicOpen := map_ideal_basicOpen, supportSet := supportSet,
supportSet_eq_iInter_zeroLocus := supportSet_eq_iInter_zeroLocus }) →
motive t |
CategoryTheory.projective_iff_llp_epimorphisms_of_isZero | Mathlib.CategoryTheory.Preadditive.Projective.LiftingProperties | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {P Z : C}
(i : Z ⟶ P),
CategoryTheory.Limits.IsZero Z →
(CategoryTheory.Projective P ↔ (CategoryTheory.MorphismProperty.epimorphisms C).llp i) |
TwoSidedIdeal.instSubSubtypeMem | Mathlib.RingTheory.TwoSidedIdeal.Basic | {R : Type u_1} → [inst : NonUnitalNonAssocRing R] → (I : TwoSidedIdeal R) → Sub ↥I |
CategoryTheory.Discrete.productEquiv_functor_map | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ {J : Type u_1} {K : Type u_2} {X Y : CategoryTheory.Discrete (J × K)} (f : X ⟶ Y),
CategoryTheory.Discrete.productEquiv.functor.map f = ULift.rec (fun down => CategoryTheory.eqToHom ⋯) f |
le_inv_iff_mul_le_one_left | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [MulLeftMono α] {a b : α}, a ≤ b⁻¹ ↔ b * a ≤ 1 |
Lean.Grind.AC.Seq.endsWithVar_k | Init.Grind.AC | Lean.Grind.AC.Seq → Lean.Grind.AC.Var → Bool |
WeierstrassCurve.Jacobian.neg_X | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} (P : Fin 3 → R), W'.neg P 0 = P 0 |
AddSubgroup.neg_mem_iff | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) {x : G}, -x ∈ H ↔ x ∈ H |
Lean.AttributeApplicationTime.afterCompilation.elim | Lean.Attributes | {motive : Lean.AttributeApplicationTime → Sort u} →
(t : Lean.AttributeApplicationTime) → t.ctorIdx = 1 → motive Lean.AttributeApplicationTime.afterCompilation → motive t |
AlgebraicGeometry.StructureSheaf.Localizations.comapFun._proof_6 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {S : Type u_1}
[inst_3 : CommRing S] {σ : R →+* S} (y : ↑(AlgebraicGeometry.PrimeSpectrum.Top S)),
IsLocalizedModule (PrimeSpectrum.comap σ y).asIdeal.primeCompl
(LocalizedModule.mkLinearMap (PrimeSpectrum.comap σ y).asIdeal.primeCompl M) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.