name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Metric.infEDist_biUnion | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {ι : Type u_2} (f : ι → Set α) (I : Set ι) (x : α),
Metric.infEDist x (⋃ i ∈ I, f i) = ⨅ i ∈ I, Metric.infEDist x (f i) | true |
RingHom.Smooth.holdsForLocalizationAway | Mathlib.RingTheory.RingHom.Smooth | RingHom.HoldsForLocalizationAway fun {R S} [CommRing R] [CommRing S] => RingHom.Smooth | true |
List.tail_append_of_ne_nil | Init.Data.List.Lemmas | ∀ {α : Type u_1} {xs ys : List α}, xs ≠ [] → (xs ++ ys).tail = xs.tail ++ ys | true |
Lean.Meta.Grind.Extension.addEMatchTheorem | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Meta.Grind.Extension →
Lean.Name →
ℕ →
List Lean.Expr →
Lean.Meta.Grind.EMatchTheoremKind →
Bool →
optParam Lean.AttributeKind Lean.AttributeKind.global →
List Lean.Meta.Grind.EMatchTheoremConstraint → Lean.MetaM Unit | true |
MeasureTheory.SignedMeasure.haveLebesgueDecomposition_neg | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} (s : MeasureTheory.SignedMeasure α) (μ : MeasureTheory.Measure α)
[s.HaveLebesgueDecomposition μ], (-s).HaveLebesgueDecomposition μ | true |
Mathlib.Meta.Positivity.Strictness.nonnegative.injEq | Mathlib.Tactic.Positivity.Core | ∀ {u : Lean.Level} {α : Q(Type u)} {zα : Q(Zero «$α»)} {pα : Q(PartialOrder «$α»)} {e : Q(«$α»)}
(pf pf_1 : Q(0 ≤ «$e»)),
(Mathlib.Meta.Positivity.Strictness.nonnegative pf = Mathlib.Meta.Positivity.Strictness.nonnegative pf_1) =
(pf = pf_1) | true |
Matrix.updateRow_reindex | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} [inst : DecidableEq l]
[inst_1 : DecidableEq m] (A : Matrix m n α) (i : l) (r : o → α) (e : m ≃ l) (f : n ≃ o),
((Matrix.reindex e f) A).updateRow i r = (Matrix.reindex e f) (A.updateRow (e.symm i) fun j => r (f j)) | true |
_private.Mathlib.LinearAlgebra.RootSystem.Chain.0.RootPairing.root_add_nsmul_mem_range_iff_le_chainTopCoeff._proof_1_5 | Mathlib.LinearAlgebra.RootSystem.Chain | ∀ {ι : Type u_2} {R : Type u_3} {M : Type u_1} {N : Type u_4} [inst : Finite ι] [inst_1 : CommRing R]
[inst_2 : CharZero R] [inst_3 : IsDomain R] [inst_4 : AddCommGroup M] [inst_5 : Module R M] [inst_6 : AddCommGroup N]
[inst_7 : Module R N] {P : RootPairing ι R M N} [inst_8 : P.IsCrystallographic] {i j : ι}
(h :... | false |
Filter.ofCardinalUnion._proof_1 | Mathlib.Order.Filter.CardinalInter | ∀ {α : Type u_1} {c : Cardinal.{u_1}} (l : Set (Set α)),
(∀ (S : Set (Set α)), Cardinal.mk ↑S < c → (∀ s ∈ S, s ∈ l) → ⋃₀ S ∈ l) →
∀ (S : Set (Set α)), Cardinal.mk ↑S < c → S ⊆ {s | sᶜ ∈ l} → ⋂₀ S ∈ {s | sᶜ ∈ l} | false |
MeasureTheory.MeasurePreserving.preErgodic_of_preErgodic_semiconj | Mathlib.Dynamics.Ergodic.Ergodic | ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → α} {μ : MeasureTheory.Measure α} {β : Type u_2}
{m' : MeasurableSpace β} {μ' : MeasureTheory.Measure β} {g : α → β},
MeasureTheory.MeasurePreserving g μ μ' → PreErgodic f μ → ∀ {f' : β → β}, Function.Semiconj g f f' → PreErgodic f' μ' | true |
Interval.subtractionCommMonoid._proof_2 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedAddMonoid α] (a : Interval α),
zsmulRec nsmulRec 0 a = 0 | false |
Ring.ofMinimalAxioms._proof_13 | Mathlib.Algebra.Ring.MinimalAxioms | ∀ {R : Type u_1} [inst : Add R] [inst_1 : Neg R] [inst_2 : Zero R] [inst_3 : One R]
(add_assoc : ∀ (a b c : R), a + b + c = a + (b + c)) (zero_add : ∀ (a : R), 0 + a = a)
(neg_add_cancel : ∀ (a : R), -a + a = 0) (n : ℕ), (Int.negSucc n).castDef = -↑(n + 1) | false |
String.decEq._proof_1 | Init.Prelude | ∀ (a : List UInt8) (isValidUTF8 : { data := { toList := a } }.IsValidUTF8),
{ toByteArray := { data := { toList := a } }, isValidUTF8 := isValidUTF8 } =
{ toByteArray := { data := { toList := a } }, isValidUTF8 := isValidUTF8 } | false |
CategoryTheory.Functor.hasColimit_map_comp_ι_comp_grothendieckProj | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {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] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} H] (F : CategoryTheory.Functor C H) [L.HasPointwiseLeftKanExtension F]
{X Y : D} (f : X ⟶ Y),
... | true |
IsPrimitiveRoot.casesOn | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | {M : Type u_1} →
[inst : CommMonoid M] →
{ζ : M} →
{k : ℕ} →
{motive : IsPrimitiveRoot ζ k → Sort u} →
(t : IsPrimitiveRoot ζ k) →
((pow_eq_one : ζ ^ k = 1) → (dvd_of_pow_eq_one : ∀ (l : ℕ), ζ ^ l = 1 → k ∣ l) → motive ⋯) → motive t | false |
AddMonCat.id_apply | Mathlib.Algebra.Category.MonCat.Basic | ∀ (M : AddMonCat) (x : ↑M), (CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id M)) x = x | true |
IO.Process.runCmdWithInput'.match_1 | Batteries.Lean.IO.Process | (cmd : String) →
(args : Array String) →
(motive :
{ stdin := IO.Process.Stdio.piped, stdout := IO.Process.Stdio.piped, stderr := IO.Process.Stdio.piped,
cmd := cmd, args := args }.stdin.toHandleType ×
IO.Process.Child
{ stdin := IO.Process.Stdio.null,
... | false |
Set.Nonempty.of_vsub_right | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : VSub α β] {s t : Set β}, (s -ᵥ t).Nonempty → t.Nonempty | true |
OmegaCompletePartialOrder.ContinuousHom.ωScottContinuous.map | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} [inst : OmegaCompletePartialOrder α] {β γ : Type u_6} {f : β → γ} {g : α → Part β},
OmegaCompletePartialOrder.ωScottContinuous g → OmegaCompletePartialOrder.ωScottContinuous fun x => f <$> g x | true |
Int.ediv_nonneg | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, 0 ≤ a → 0 ≤ b → 0 ≤ a / b | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.ConcreteCategory.0.CategoryTheory.Limits.Concrete.Pi.map_ext.match_1_1 | Mathlib.CategoryTheory.Limits.Shapes.ConcreteCategory | ∀ {J : Type u_1} (motive : CategoryTheory.Discrete J → Prop) (h : CategoryTheory.Discrete J),
(∀ (j : J), motive { as := j }) → motive h | false |
IsOpen.measure_eq_zero_iff | Mathlib.MeasureTheory.Measure.OpenPos | ∀ {X : Type u_1} [inst : TopologicalSpace X] {m : MeasurableSpace X} (μ : MeasureTheory.Measure X) [μ.IsOpenPosMeasure]
{U : Set X}, IsOpen U → (μ U = 0 ↔ U = ∅) | true |
CategoryTheory.FunctorToTypes.binaryCoproductIso._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.FunctorToTypes | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] (F G : CategoryTheory.Functor C (Type u_2)),
CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.pair F G) | false |
continuousFunctionalCalculus._proof_2 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic | ContinuousMul ℂ | false |
Sigma.Lex.preorder.match_1 | Mathlib.Data.Sigma.Order | ∀ {ι : Type u_2} {α : ι → Type u_1} (motive : (Σₗ (i : ι), α i) → Prop) (x : Σₗ (i : ι), α i),
(∀ (fst : ι) (a : α fst), motive ⟨fst, a⟩) → motive x | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.etaPossibilities._sunfold | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | Lean.Expr →
List Lean.FVarId →
Bool →
Lean.Meta.RefinedDiscrTree.LazyEntry →
ReaderT Lean.Meta.RefinedDiscrTree.Context✝ Lean.MetaM
(List (Lean.Meta.RefinedDiscrTree.Key × Lean.Meta.RefinedDiscrTree.LazyEntry)) | false |
Std.Channel.Sync.recv | Std.Sync.Channel | {α : Type} → [Inhabited α] → Std.Channel.Sync α → BaseIO α | true |
_private.Mathlib.RingTheory.Congruence.Basic.0.RingCon.instIsCentralScalarQuotient._proof_1 | Mathlib.RingTheory.Congruence.Basic | ∀ {α : Type u_1} {R : Type u_2} [inst : Add R] [inst_1 : MulOneClass R] [inst_2 : SMul α R]
[inst_3 : IsScalarTower α R R] (c : RingCon R) [inst_4 : SMul αᵐᵒᵖ R] [inst_5 : IsCentralScalar α R],
IsCentralScalar α c.Quotient | false |
CategoryTheory.cones_obj_map_app | 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) {X Y : Cᵒᵖ} (f : X ⟶ Y)
(a : (CategoryTheory.yoneda.obj F).obj ((CategoryTheory.Functor.const J).op.obj X)) (X_1 : J),
(((CategoryTheory.cones J C).obj F).map f ... | true |
CategoryTheory.ShortComplex.LeftHomologyData.map._proof_2 | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {S : CategoryTheory.ShortComplex C} (h : S.LeftHomologyData)
(F : CategoryTheory.Fun... | false |
Lean.Meta.FunIndParamKind.dropped.elim | Lean.Meta.Tactic.FunIndInfo | {motive : Lean.Meta.FunIndParamKind → Sort u} →
(t : Lean.Meta.FunIndParamKind) → t.ctorIdx = 0 → motive Lean.Meta.FunIndParamKind.dropped → motive t | false |
Lean.ProjectionFunctionInfo | Lean.ProjFns | Type | true |
LinearMap.vecEmpty_apply | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {M : Type v} {M₃ : Type y} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₃]
[inst_3 : Module R M] [inst_4 : Module R M₃] (m : M), LinearMap.vecEmpty m = ![] | true |
Quiver.arborescenceMk._proof_1 | Mathlib.Combinatorics.Quiver.Arborescence | ∀ {V : Type u_1} [inst : Quiver V] (r : V) (height : V → ℕ),
(∀ ⦃a b : V⦄ (a_1 : a ⟶ b), height a < height b) →
(∀ (b : V), b = r ∨ ∃ a, Nonempty (a ⟶ b)) → ∀ (b : V), Nonempty (Quiver.Path r b) | false |
PMF.toMeasure_ofMultiset_apply | Mathlib.Probability.Distributions.Uniform | ∀ {α : Type u_1} {s : Multiset α} (hs : s ≠ 0) (t : Set α) [inst : MeasurableSpace α],
MeasurableSet t →
(PMF.ofMultiset s hs).toMeasure t = (∑' (x : α), ↑(Multiset.count x (Multiset.filter (fun x => x ∈ t) s))) / ↑s.card | true |
WithBot.one | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | {α : Type u} → [One α] → One (WithBot α) | true |
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.isLimit | Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
{H : J.OneHypercoverFamily} →
{P : CategoryTheory.Functor Cᵒᵖ A} →
(∀ ⦃X : C⦄ (E : J.OneHyperco... | true |
ChainComplex.prev | Mathlib.Algebra.Homology.HomologicalComplex | ∀ (α : Type u_2) [inst : AddRightCancelSemigroup α] [inst_1 : One α] (i : α), (ComplexShape.down α).prev i = i + 1 | true |
AlgebraicGeometry.Scheme.coe_homeoOfIso | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (e : X ≅ Y), ⇑(AlgebraicGeometry.Scheme.homeoOfIso e) = ⇑e.hom | true |
ZeroAtInftyContinuousMap.instNonUnitalNormedRing._proof_2 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : NonUnitalNormedRing β]
(x y : ZeroAtInftyContinuousMap α β), dist x y = ‖-x + y‖ | false |
CategoryTheory.Limits.mapPair._proof_11 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
{F G : CategoryTheory.Functor (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) C}
(f : F.obj { as := CategoryTheory.Limits.WalkingPair.left } ⟶ G.obj { as := CategoryTheory.Limits.WalkingPair.left })
(g :
F.obj { as := CategoryTheory.Li... | false |
_private.Mathlib.MeasureTheory.Function.Piecewise.0.IndexedPartition.stronglyMeasurable_piecewise._simp_1_7 | Mathlib.MeasureTheory.Function.Piecewise | ∀ {n : ℕ} {a b : Fin n}, (a = b) = (↑a = ↑b) | false |
autEquivZmod._proof_1 | Mathlib.FieldTheory.KummerExtension | ∀ {K : Type u_1} [inst : Field K] {n : ℕ} {a : K},
Irreducible (Polynomial.X ^ n - Polynomial.C a) → ∀ {ζ : K}, IsPrimitiveRoot ζ n → ∃ x, x ∈ primitiveRoots n K | false |
CategoryTheory.Presieve.hasPullback | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {X : C} {R : CategoryTheory.Presieve X} {Y : C} (f : Y ⟶ X)
[self : R.HasPullbacks f] {Z : C} {h : Z ⟶ X}, R h → CategoryTheory.Limits.HasPullback h f | true |
Mathlib.Linter.Style.openClassical.initFn._@.Mathlib.Tactic.Linter.Style.273924139._hygCtx._hyg.2 | Mathlib.Tactic.Linter.Style | IO Unit | false |
Lean.Parser.TokenCacheEntry.startPos | Lean.Parser.Types | Lean.Parser.TokenCacheEntry → String.Pos.Raw | true |
selfAdjoint.instCommRingSubtypeMemAddSubgroup._proof_9 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : StarRing R] (x y : ↥(selfAdjoint R)), ↑(x - y) = ↑x - ↑y | false |
CategoryTheory.PullbackShift.functor.eq_1 | Mathlib.CategoryTheory.Shift.Pullback | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_2} {B : Type u_3} [inst_1 : AddMonoid A]
[inst_2 : AddMonoid B] (φ : A →+ B) [inst_3 : CategoryTheory.HasShift C B] {D : Type u_4}
[inst_4 : CategoryTheory.Category.{v_2, u_4} D] [inst_5 : CategoryTheory.HasShift D B]
(F : CategoryTheory.F... | true |
NonAssocSemiring.natCast_succ | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u} [self : NonAssocSemiring α] (n : ℕ), ↑(n + 1) = ↑n + 1 | true |
Vector.not_mem_range_self | Init.Data.Vector.Range | ∀ {n : ℕ}, n ∉ Vector.range n | true |
CategoryTheory.SingleFunctors.postcompPostcompIso_inv_hom_app | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} {E' : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
[inst_3 : CategoryTheory.Category.{v_4, u_4} E'] {A : Type u_5} [inst_4 : AddMonoid A]
[inst_5 : CategoryTheo... | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_shiftConcat_eq_of_lt._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {k : ℕ}, x.toNat < 2 ^ k → 2 ^ k * 2 ≤ 2 ^ w → ¬x.toNat * 2 < 2 ^ w → False | false |
ContinuousWithinAt.insert | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α}
{x : α}, ContinuousWithinAt f s x → ContinuousWithinAt f (insert x s) x | true |
ArchimedeanClass.stdPart_add_eq_left | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K] {x y : K},
0 < ArchimedeanClass.mk y → ArchimedeanClass.stdPart (x + y) = ArchimedeanClass.stdPart x | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_sdiv_eq_decide._simp_1_3 | Init.Data.BitVec.Bitblast | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | false |
Lean.Elab.Command.Structure.StructFieldViewDefault.autoParam.inj | Lean.Elab.Structure | ∀ {tactic tactic_1 : Lean.Syntax},
Lean.Elab.Command.Structure.StructFieldViewDefault.autoParam tactic =
Lean.Elab.Command.Structure.StructFieldViewDefault.autoParam tactic_1 →
tactic = tactic_1 | true |
_private.Mathlib.Computability.EpsilonNFA.0.εNFA.mem_evalFrom_iff_exists_path.match_1_1 | Mathlib.Computability.EpsilonNFA | ∀ {α : Type u_1} {σ : Type u_2} (M : εNFA α σ) {s₁ s₂ : σ}
(motive : (∃ n, M.IsPath s₁ s₂ (List.replicate n none)) → Prop) (h : ∃ n, M.IsPath s₁ s₂ (List.replicate n none)),
(∀ (n : ℕ) (h : M.IsPath s₁ s₂ (List.replicate n none)), motive ⋯) → motive h | false |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.instHasSpectralSequenceFinHAddNatOfNatProdIntCoreE₂CohomologicalFin._proof_7 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {l : ℕ} (k t : ℕ), k + 1 + t < l → t < l | false |
CategoryTheory.Limits.evaluationJointlyReflectsLimits._proof_2 | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} J] {K : Type u_1} [inst_2 : CategoryTheory.Category.{u_4, u_1} K]
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} (c : CategoryTheory.Limits.Cone F)
(t : (k : K) → CategoryTheory.... | false |
AddEquiv.instUnique.eq_1 | Mathlib.Algebra.Group.Equiv.Basic | ∀ {M : Type u_16} {N : Type u_17} [inst : Unique M] [inst_1 : Unique N] [inst_2 : Add M] [inst_3 : Add N],
AddEquiv.instUnique = { default := AddEquiv.ofUnique, uniq := ⋯ } | true |
_private.Batteries.Data.List.Lemmas.0.List.countPBefore_cons_succ._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {p : α → Bool} {i : ℕ} {a : α},
List.countPBefore p (a :: xs) (i + 1) = if p a = true then List.countPBefore p xs i + 1 else List.countPBefore p xs i | false |
instModuleFormalMultilinearSeriesOfContinuousConstSMulOfSMulCommClass._proof_7 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E] [inst_6 : AddCommMonoid F]
[inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : ContinuousAdd ... | false |
_private.Init.Data.String.Extra.0.String.removeNumLeadingSpaces | Init.Data.String.Extra | ℕ → String → String | true |
_private.Mathlib.Data.List.Basic.0.List.eq_cons_of_length_one._proof_1_6 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} {l : List α} (h : l.length = 1) (n : ℕ), n + 1 ≤ [l.get ⟨0, ⋯⟩].length → n < [l.get ⟨0, ⋯⟩].length | false |
Lean.Meta.UnificationHint.noConfusionType | Lean.Meta.UnificationHint | Sort u → Lean.Meta.UnificationHint → Lean.Meta.UnificationHint → Sort u | false |
MeasureTheory.SimpleFunc.instNonUnitalNonAssocSemiring._proof_4 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : NonUnitalNonAssocSemiring β]
(a : MeasureTheory.SimpleFunc α β), a * 0 = 0 | false |
Complex.tanh_ofReal_im | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), (Complex.tanh ↑x).im = 0 | true |
Mathlib.Tactic.Abel.abelConv | Mathlib.Tactic.Abel | Lean.ParserDescr | true |
CategoryTheory.Limits.BinaryBicones.functoriality | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{D : Type uD} →
[inst_2 : CategoryTheory.Category.{uD', uD} D] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
(P Q : C) →
(F : CategoryThe... | true |
Aesop.RappData.metaState | Aesop.Tree.Data | {Goal MVarCluster : Type} → Aesop.RappData Goal MVarCluster → Lean.Meta.SavedState | true |
AddValuation.comap_id | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀]
(v : AddValuation R Γ₀), AddValuation.comap (RingHom.id R) v = v | true |
_private.Mathlib.Geometry.Convex.Cone.Basic.0.ConvexCone.IsGenerating.isReproducing.match_1_4 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : AddCommGroup M] [inst_3 : Module R M]
{C : ConvexCone R M} (motive : (↑C).Nonempty → Prop) (hne : (↑C).Nonempty),
(∀ (c : M) (hc : c ∈ ↑C), motive ⋯) → motive hne | false |
Associated.neg_neg | Mathlib.Algebra.Ring.Associated | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : HasDistribNeg M] {a b : M}, Associated a b → Associated (-a) (-b) | true |
FirstOrder.Language.ElementaryEmbedding.toEmbedding._proof_2 | Mathlib.ModelTheory.ElementaryMaps | ∀ {L : FirstOrder.Language} {M : Type u_4} {N : Type u_3} [inst : L.Structure M] [inst_1 : L.Structure N]
(f : L.ElementaryEmbedding M N) {x : ℕ} (R : L.Relations x) (x_1 : Fin x → M),
FirstOrder.Language.Structure.RelMap R (⇑f ∘ x_1) ↔ FirstOrder.Language.Structure.RelMap R x_1 | false |
LinearMap.BilinForm.toLinHomAux₁ | Mathlib.LinearAlgebra.BilinearForm.Hom | {R : Type u_1} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → LinearMap.BilinForm R M → M → M →ₗ[R] R | true |
mabs_le | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b : G}, |a|ₘ ≤ b ↔ b⁻¹ ≤ a ∧ a ≤ b | true |
PresheafOfModules.Sheafify.map_smul_eq | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.obj)
[inst_1 : CategoryTheory.Presheaf.IsLocallyInjective J α] [inst_2 : CategoryTheory.Presheaf.IsLocallySurjective J α]... | true |
Equiv.piCongrFiberwise_apply | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_9} {β : Type u_10} {γ₁ : α → Type u_11} {γ₂ : β → Type u_12} {f : α → β}
(e : (b : β) → ((σ : { a // f a = b }) → γ₁ ↑σ) ≃ γ₂ b) (g : (a : α) → γ₁ a) (b : β),
(Equiv.piCongrFiberwise e) g b = (e b) fun σ => g ↑σ | true |
continuous_inf_dom_left₂ | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u_5} {Y : Type u_6} {Z : Type u_7} {f : X → Y → Z} {ta1 ta2 : TopologicalSpace X}
{tb1 tb2 : TopologicalSpace Y} {tc1 : TopologicalSpace Z},
(Continuous fun p => f p.1 p.2) → Continuous fun p => f p.1 p.2 | true |
Int.fdiv_add_fmod' | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), b * a.fdiv b + a.fmod b = a | true |
CategoryTheory.IsReflexivePair.mk | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B : C} {f g : A ⟶ B},
(∃ s,
CategoryTheory.CategoryStruct.comp s f = CategoryTheory.CategoryStruct.id B ∧
CategoryTheory.CategoryStruct.comp s g = CategoryTheory.CategoryStruct.id B) →
CategoryTheory.IsReflexivePair f g | true |
MeasureTheory.IsSeparable | Mathlib.MeasureTheory.Measure.SeparableMeasure | {X : Type u_1} → [m : MeasurableSpace X] → MeasureTheory.Measure X → Prop | true |
one_lt_leOnePart._simp_2 | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] {a : α} [MulLeftMono α], a < 1 → (1 < a⁻ᵐ) = True | false |
Affine.Simplex.incenter_notMem_affineSpan_faceOpposite | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (i : Fin (n + 1)),
s.incenter ∉ affineSpan ℝ (Set.range (s.faceOpposite i).points) | true |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.mapZ_comp_assoc | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) {X Y X' Y' : C} {f : X ⟶ Y} {g : X' ⟶ Y'}
(φ : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g) {X'' Y'' : C} {h : X'' ⟶ Y''}
(ψ : CategoryTheory.Arrow.mk g ⟶... | true |
AddMonoid.End.coe_one | Mathlib.Algebra.Group.Hom.Defs | ∀ (M : Type u_4) [inst : AddZero M], ⇑1 = id | true |
String.Slice.Pos.startInclusive_le_str | Init.Data.String.Basic | ∀ {s : String.Slice} {pos : s.Pos}, s.startInclusive ≤ pos.str | true |
CategoryTheory.IsExponentiable | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → [CategoryTheory.ChosenPullbacks C] → CategoryTheory.MorphismProperty C | true |
AddCommMonoid.zmodModule._proof_1 | Mathlib.Algebra.Module.ZMod | ∀ {n : ℕ} {M : Type u_1} [inst : AddCommMonoid M],
(∀ (x : M), n • x = 0) → ∀ (c : ℕ) (x : M), (c % n + c / n * n) • x = c • x → (c % n) • x = c • x | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.card_fixedPoints_modEq._simp_1_1 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | false |
Filter.limsSup | Mathlib.Order.LiminfLimsup | {α : Type u_1} → [ConditionallyCompleteLattice α] → Filter α → α | true |
CategoryTheory.Limits.MultispanIndex.ι_fstSigmaMap_assoc | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) [inst_1 : CategoryTheory.Limits.HasCoproduct I.left]
[inst_2 : CategoryTheory.Limits.HasCoproduct I.right] (b : J.L) {Z : C} (h : ∐ I.right ⟶ Z),
CategoryTheory.Catego... | true |
RCLike.continuous_ofReal | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], Continuous RCLike.ofReal | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rco.Internal.toList_eq_toList_iter | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.Rxo.IsAlwaysFinite α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α] {r : Std.Rco α},
r.toList = (Std.Rco.Internal.iter r).toList | true |
CategoryTheory.ShortComplex.SnakeInput.L₀X₂ToP_comp_pullback_snd | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.CategoryStruct.comp S.L₀X₂ToP (CategoryTheory.Limits.pullback.snd S.L₁.g S.v₀₁.τ₃) = S.L₀.g | true |
_private.Lean.Compiler.IR.SimpleGroundExpr.0.Lean.IR.compileToSimpleGroundExpr.compileFinalExpr._sparseCasesOn_13 | Lean.Compiler.IR.SimpleGroundExpr | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
AddEquiv.opOp | Mathlib.Algebra.Group.Equiv.Opposite | (M : Type u_3) → [inst : Add M] → M ≃+ Mᵃᵒᵖᵃᵒᵖ | true |
Finset.Nontrivial.instDecidablePred._proof_3 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} (h : Multiset.Nodup ⟦[]⟧), ¬{ val := ⟦[]⟧, nodup := h }.Nontrivial | false |
rootsOfUnityEquivNthRoots._proof_6 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ (R : Type u_1) (k : ℕ) [inst : NeZero k] [inst_1 : CommRing R] [inst_2 : IsDomain R]
(x : { x // x ∈ Polynomial.nthRoots k 1 }),
{ val := ↑x, inv := ↑x ^ (k - 1), val_inv := ⋯, inv_val := ⋯ } ∈ rootsOfUnity k R | false |
Action.diagonalSuccIsoTensorTrivial._proof_2 | Mathlib.CategoryTheory.Action.Monoidal | ∀ (G : Type u_1) [inst : Group G] (n : ℕ) (x : G),
CategoryTheory.CategoryStruct.comp
((Action.trivial G
(CategoryTheory.MonoidalCategoryStruct.tensorObj (Action.leftRegular G) (Action.trivial G (Fin n → G))).V).ρ
x)
(Fin.insertNthEquiv (fun x => G) 0).toIso.hom =
CategoryTheory.Ca... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.