name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.ErrorExplanation.instToJsonMetadata.toJson | Lean.ErrorExplanation | Lean.ErrorExplanation.Metadata → Lean.Json | null | true |
_private.Mathlib.Analysis.Calculus.ImplicitFunction.ProdDomain.0.HasStrictFDerivAt.implicitFunctionDataOfProdDomain._proof_3 | Mathlib.Analysis.Calculus.ImplicitFunction.ProdDomain | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], RingHomSurjective (RingHom.id 𝕜) | null | false |
Metric.cthickening_empty | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] (δ : ℝ), Metric.cthickening δ ∅ = ∅ | The closed thickening of the empty set is empty. | true |
AlgebraicGeometry.Scheme.Modules.conjugateEquiv_pullbackId_hom | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ (X : AlgebraicGeometry.Scheme),
(CategoryTheory.conjugateEquiv CategoryTheory.Adjunction.id
(AlgebraicGeometry.Scheme.Modules.pullbackPushforwardAdjunction (CategoryTheory.CategoryStruct.id X)))
(AlgebraicGeometry.Scheme.Modules.pullbackId X).hom =
(AlgebraicGeometry.Scheme.Modules.pushforwardId X... | null | true |
HomologicalComplex₂.toGradedObjectMap | Mathlib.Algebra.Homology.HomologicalBicomplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{I₁ : Type u_2} →
{I₂ : Type u_3} →
{c₁ : ComplexShape I₁} →
{c₂ : ComplexShape I₂} →
{K L : HomologicalComplex₂ C c₁ c₂} → (K ⟶ L) → (K.toGraded... | The morphism of graded objects induced by a morphism of bicomplexes. | true |
Manifold.IsSubmersionAtOfComplement.instNormedAddCommGroupSmallComplement._proof_50 | Mathlib.Geometry.Manifold.Submersion | ∀ {𝕜 : Type u_2} {E'' : Type u_3} {F : Type u_4} {H : Type u_5} {G : Type u_6} {E : Type u_1}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
[inst_3 : NormedAddCommGroup E''] [inst_4 : NormedSpace 𝕜 E''] [inst_5 : NormedAddCommGroup F]
[inst_6 : NormedSpace 𝕜 F]... | null | false |
_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 | null | false |
Lean.Meta.useEtaStruct | Lean.Meta.Basic | Lean.Name → Lean.MetaM Bool | `useEtaStruct inductName` return `true` if we eta for structures is enabled for
for the inductive datatype `inductName`.
Recall we have three different settings: `.none` (never use it), `.all` (always use it), `.notClasses`
(enabled only for non-recursive structure types that are not classes).
The parameter `inductNa... | true |
CategoryTheory.Endofunctor.Algebra.functorOfNatTransId_inv_app_f | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
(X : CategoryTheory.Endofunctor.Algebra F),
(CategoryTheory.Endofunctor.Algebra.functorOfNatTransId.inv.app X).f = CategoryTheory.CategoryStruct.id X.a | null | true |
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 | null | true |
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 | null | true |
SkewMonoidAlgebra.coeff_single | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] (a : G) (b : k) [inst_1 : DecidableEq G],
(SkewMonoidAlgebra.single a b).coeff = Pi.single a b | null | true |
CategoryTheory.CommGrp.instCategory._proof_7 | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
autoParam
(∀ {X Y : CategoryTheory.CommGrp C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f = f)
Ca... | null | false |
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 | null | true |
Filter.Germ.total | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u} {β : Type v} {φ : Ultrafilter α} [inst : LE β] [Std.Total fun x1 x2 => x1 ≤ x2],
Std.Total fun x1 x2 => x1 ≤ x2 | null | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect.0.Lean.Elab.Tactic.BVDecide.Frontend.LemmaM.run.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | {α : Type} →
(motive : α × Lean.Elab.Tactic.BVDecide.Frontend.LemmaState → Sort u_1) →
(x : α × Lean.Elab.Tactic.BVDecide.Frontend.LemmaState) →
((res : α) → (state : Lean.Elab.Tactic.BVDecide.Frontend.LemmaState) → motive (res, state)) → motive x | null | false |
Set.Finset.coe_einfsep | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u_1} [inst : EDist α] {s : Finset α}, (↑s).einfsep = s.offDiag.inf (Function.uncurry edist) | null | true |
EReal.sub_add_cancel_right | Mathlib.Data.EReal.Operations | ∀ {a : EReal} {b : ℝ}, ↑b - (a + ↑b) = -a | null | true |
_private.Mathlib.MeasureTheory.Measure.Doubling.0.IsUnifLocDoublingMeasure.eventually_measure_mul_le_scalingConstantOf_mul._simp_1_1 | Mathlib.MeasureTheory.Measure.Doubling | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Zero α] [IsBotZeroClass α] {a : α}, (0 ≤ a) = True | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_union._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.vietoris.isCompact_aux._proof_1_7 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] {K : Set α} {s : Set (Set α)},
s ⊆ 𝒫 K →
∀ (S : Set (Set (Set α))),
∀ L ∈ s,
L \ ⋃₀ {U | IsOpen U ∧ {s | (s ∩ U).Nonempty} ∈ S} ⊆ K \ ⋃₀ {U | IsOpen U ∧ {s | (s ∩ U).Nonempty} ∈ S} ∩ L | null | false |
instAntisymmLe | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : PartialOrder α], Std.Antisymm fun x1 x2 => x1 ≤ x2 | null | true |
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 | null | true |
CategoryTheory.AddGrp.instCategory._proof_8 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C],
autoParam
(∀ {X Y : CategoryTheory.AddGrp C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f)
CategoryTheory.Category.comp_id._autoParam | null | false |
Alexandrov.principals | Mathlib.Topology.Sheaves.Alexandrov | (X : Type v) →
[inst : TopologicalSpace X] →
[inst_1 : Preorder X] → [Topology.IsUpperSet X] → CategoryTheory.Functor X (TopologicalSpace.Opens X)ᵒᵖ | The functor sending `x : X` to the principal open associated with `x`. | true |
TopologicalSpace.Opens.coe_compl | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_2} [inst : TopologicalSpace α] (s : TopologicalSpace.Opens α), ↑s.compl = (↑s)ᶜ | null | true |
ComplexShape.σ_symm | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ {I₁ : Type u_1} {I₂ : Type u_2} {I₁₂ : Type u_4} (c₁ : ComplexShape I₁) (c₂ : ComplexShape I₂)
(c₁₂ : ComplexShape I₁₂) [inst : TotalComplexShape c₁ c₂ c₁₂] [inst_1 : TotalComplexShape c₂ c₁ c₁₂]
[inst_2 : TotalComplexShapeSymmetry c₁ c₂ c₁₂] [inst_3 : TotalComplexShapeSymmetry c₂ c₁ c₁₂]
[TotalComplexShapeSymm... | null | true |
Lean.trace.profiler.threshold | Lean.Util.Trace | Lean.Option ℕ | null | true |
_private.Mathlib.Tactic.NormNum.Ineq.0.Mathlib.Meta.NormNum.evalLE.core.match_3 | Mathlib.Tactic.NormNum.Ineq | {u : Lean.Level} →
{α : Q(Type u)} →
{a b : Q(«$α»)} →
(motive : Mathlib.Meta.NormNum.Result a → Mathlib.Meta.NormNum.Result b → Sort u_1) →
(ra : Mathlib.Meta.NormNum.Result a) →
(rb : Mathlib.Meta.NormNum.Result b) →
((val : Bool) →
(proof : Lean.Expr) →
... | null | false |
RelHom.coe_mul | Mathlib.Algebra.Order.Group.End | ∀ {α : Type u_1} {r : α → α → Prop} (f g : r →r r), ⇑(f * g) = ⇑f ∘ ⇑g | null | true |
_private.Mathlib.Util.WhatsNew.0.Mathlib.WhatsNew.whatsNew._sparseCasesOn_3 | Mathlib.Util.WhatsNew | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
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 | null | false |
_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 | null | true |
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 𝕜... | null | true |
RBTree.RBSet.contains | BatteriesRecycling.RBTree.Basic | {α : Type u_1} → {cmp : α → α → Ordering} → RBTree.RBSet α cmp → α → Bool | `O(log n)`. Returns true if the given key `a` is in the RBSet. | true |
ContinuousLinearMap.seminorm._proof_3 | Mathlib.Analysis.Normed.Operator.Basic | ∀ {F : Type u_1} [inst : SeminormedAddCommGroup F], ContinuousAdd F | null | false |
_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 ∈ 𝒜) | null | false |
NonUnitalSubsemiring.instBot._proof_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {a b : R}, a ∈ {0} → b ∈ {0} → a + b ∈ {0} | null | false |
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} } | null | false |
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) | null | false |
_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) | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Proof.0.Lean.Meta.Grind.Arith.CommRing.getPolyConst.match_1 | Lean.Meta.Tactic.Grind.Arith.CommRing.Proof | (motive : Lean.Grind.CommRing.Poly → Sort u_1) →
(p : Lean.Grind.CommRing.Poly) →
((k : ℤ) → motive (Lean.Grind.CommRing.Poly.num k)) → ((x : Lean.Grind.CommRing.Poly) → motive x) → motive p | null | false |
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 | null | false |
_private.Mathlib.Combinatorics.Matroid.Rank.Cardinal.0.Matroid.cRk_map_image_lift._simp_1_3 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
FreeAddSemigroup.rec._@.Mathlib.Algebra.Free.2508704951._hygCtx._hyg.3 | Mathlib.Algebra.Free | {α : Type u} →
{motive : FreeAddSemigroup α → Sort u_1} →
((head : α) → (tail : List α) → motive { head := head, tail := tail }) → (t : FreeAddSemigroup α) → motive t | null | false |
Lean.Grind.CommRing.Mon.concat.eq_1 | Init.Grind.Ring.CommSolver | ∀ (m₂ : Lean.Grind.CommRing.Mon), Lean.Grind.CommRing.Mon.unit.concat m₂ = m₂ | null | true |
_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 | null | false |
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 | null | true |
_private.Std.Http.Protocol.H1.0.Std.Http.Protocol.H1.Machine.processParsedHeader._unsafe_rec | Std.Http.Protocol.H1 | {dir : Std.Http.Protocol.H1.Direction} →
Std.Http.Protocol.H1.Machine dir → ℕ → ℕ → String → String → Std.Http.Protocol.H1.Machine dir | null | false |
EmbeddingLike.casesOn | Mathlib.Data.FunLike.Embedding | {F : Sort u_1} →
{α : Sort u_2} →
{β : Sort u_3} →
[inst : FunLike F α β] →
{motive : EmbeddingLike F α β → Sort u} →
(t : EmbeddingLike F α β) → ((injective' : ∀ (f : F), Function.Injective ⇑f) → motive ⋯) → motive t | null | false |
Substring.Raw.Valid.validFor | Batteries.Data.String.Lemmas | ∀ {s : Substring.Raw}, s.Valid → ∃ l m r, Substring.Raw.ValidFor l m r s | null | true |
LinearIsometry.rTensor_apply | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : InnerProductSpace 𝕜 G] (f : E →ₗᵢ[𝕜] F) (x : TensorProduct... | null | true |
ArchimedeanClass.stdPart_sub_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 | null | true |
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... | null | false |
Std.Tactic.BVDecide.LRAT.Internal.instBEqDefaultClause.beq._proof_4 | Std.Tactic.BVDecide.LRAT.Internal.Clause | ∀ {numVarsSucc : ℕ} (a b : Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin numVarsSucc))
(h : (a == b) = true), ⋯ ≍ ⋯ | null | false |
Polynomial.degree_ne_bot | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.degree ≠ ⊥ ↔ p ≠ 0 | null | true |
bernoulliFun_one | Mathlib.NumberTheory.ZetaValues | ∀ (x : ℝ), bernoulliFun 1 x = x - 1 / 2 | null | true |
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 } | null | false |
Mathlib.Tactic.RingNF.Config | Mathlib.Tactic.Ring.RingNF | Type | Configuration for `ring_nf`. | true |
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 :... | The `DFinsupp` version of `Finsupp.lsum`.
See note [bundled maps over different rings] for why separate `R` and `S` semirings are used. | true |
Finset.diag_eq_filter | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {s : Finset α} [inst : DecidableEq α], s.diag = {a ∈ s ×ˢ s | a.1 = a.2} | null | true |
_private.Mathlib.Order.Defs.Unbundled.0.of_eq.match_1_1 | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} (motive : (x x_1 : α) → x = x_1 → Prop) (x x_1 : α) (x_2 : x = x_1),
(∀ (x : α), motive x x ⋯) → motive x x_1 x_2 | null | false |
AlgebraicGeometry.Scheme.Cover.glueMorphisms._proof_2 | Mathlib.AlgebraicGeometry.Gluing | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover),
CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Cover.ulift 𝒰).fromGlued | null | false |
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) →
... | null | false |
MonadShareCommon.mk._flat_ctor | Init.ShareCommon | {m : Type u → Type v} → ({α : Type u} → α → m α) → MonadShareCommon m | null | false |
ContinuousMap.norm_eq_iSup_norm | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} {E : Type u_3} [inst : TopologicalSpace α] [inst_1 : CompactSpace α]
[inst_2 : SeminormedAddCommGroup E] (f : C(α, E)), ‖f‖ = ⨆ x, ‖f x‖ | null | true |
LinearMap.smulRightₗ | Mathlib.Algebra.Module.LinearMap.End | {R : Type u_1} →
{M : Type u_4} →
{M₂ : Type u_6} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : Module R M] → [inst_4 : Module R M₂] → (M₂ →ₗ[R] R) →ₗ[R] M →ₗ[R] M₂ →ₗ[R] M | The family of linear maps `M₂ → M` parameterised by `f ∈ M₂ → R`, `x ∈ M`, is linear in `f`, `x`.
This is also known as a rank-one operator.
See `ContinuousLinearMap.smulRightL` for the continuous version of this, and see
`InnerProductSpace.rankOne` for the rank-one operator on Hilbert spaces. | true |
StrictMono.wellFoundedLT | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} [WellFoundedLT β],
StrictMono f → WellFoundedLT α | null | true |
NumberField.FinitePlace.mk_eq_iff._simp_1 | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | ∀ {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₂) | null | false |
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 | null | false |
_private.Mathlib.Data.Fin.Basic.0.Fin.exists_eq_add_of_lt._simp_1_3 | Mathlib.Data.Fin.Basic | ∀ {n m : ℕ}, (n < m) = (↑n < ↑m) | null | false |
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 | null | true |
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 (CategoryTheory.Over.Hom.left p)).... | null | true |
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) | null | true |
Set.mem_smul | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {s : Set α} {t : Set β} {b : β},
b ∈ s • t ↔ ∃ x ∈ s, ∃ y ∈ t, x • y = b | null | true |
Append.mk.noConfusion | Init.Prelude | {α : Type u} →
{P : Sort u_1} →
{append append' : α → α → α} → { append := append } = { append := append' } → (append ≍ append' → P) → P | null | false |
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' := ⋯ } | null | true |
_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 | null | false |
_private.Mathlib.CategoryTheory.MorphismProperty.Comma.0.CategoryTheory.MorphismProperty.instIsClosedUnderIsomorphismsOverOverObjOfRespectsIso._proof_1 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {W : CategoryTheory.MorphismProperty T} {X : T}
[W.RespectsIso], W.overObj.IsClosedUnderIsomorphisms | null | false |
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 | null | false |
MeasureTheory.SimpleFunc.integral_smul | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {E : Type u_2} {𝕜 : Type u_4} [inst : NormedAddCommGroup E] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} [inst_1 : NormedSpace ℝ E] [inst_2 : DistribSMul 𝕜 E] [SMulCommClass ℝ 𝕜 E] (c : 𝕜)
{f : MeasureTheory.SimpleFunc α E},
MeasureTheory.Integrable (⇑f) μ →
MeasureTheory.SimpleF... | null | true |
_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 | null | 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 | null | false |
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) | null | false |
_private.Lean.Compiler.LCNF.Types.0.Lean.Compiler.LCNF.toLCNFType.go._unsafe_rec | Lean.Compiler.LCNF.Types | Lean.Expr → Lean.MetaM Lean.Expr | null | false |
_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 : ... | null | false |
instAddGroupUniformOnFun.eq_1 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : AddGroup β],
instAddGroupUniformOnFun =
{ toAddMonoid := instAddMonoidUniformOnFun, toNeg := instNegUniformOnFun, toSub := instSubUniformOnFun,
sub_eq_add_neg := ⋯, zsmul := instAddGroupUniformOnFun._aux_2, zsmul_zero' := ⋯, zsmul_succ' := ⋯,
... | null | true |
Finpartition.map | Mathlib.Order.Partition.Finpartition | {α : Type u_1} →
[inst : Lattice α] →
[inst_1 : OrderBot α] →
{β : Type u_2} →
[inst_2 : Lattice β] → [inst_3 : OrderBot β] → {a : α} → (e : α ≃o β) → Finpartition a → Finpartition (e a) | Transfer a finpartition over an order isomorphism. | true |
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 ℤ)) | null | false |
_private.Mathlib.Algebra.Homology.ModelCategory.Injective.0.CochainComplex.Plus.modelCategoryQuillen.instHasTwoOutOfThreePropertyWeakEquivalences._proof_1 | Mathlib.Algebra.Homology.ModelCategory.Injective | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
(HomotopicalAlgebra.weakEquivalences (CochainComplex.Plus C)).HasTwoOutOfThreeProperty | null | false |
Graph.not_isLink_of_notMem_edgeSet | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x y : α} {e : β} {G : Graph α β}, e ∉ G.edgeSet → ¬G.IsLink e x y | null | true |
_private.Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks.0.CategoryTheory.Limits.PreservesPullback.iso_inv_fst._simp_1_2 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.inv f = g) = (f = CategoryTheory.CategoryStruct.comp α.hom g) | null | false |
_private.Init.Data.Slice.List.Lemmas.0.ListSlice.instLawfulSliceSizeTakeListIteratorIdListSliceData._simp_1 | Init.Data.Slice.List.Lemmas | ∀ {α : Type u} {s : ListSlice α}, Std.ToIterator.iter s = Std.Slice.Internal.iter s | null | false |
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 | **Alias** of `Ideal.isPrimary_finsetInf`. | true |
Subgroup.isFiniteRelIndex_top_iff._simp_2 | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, H.IsFiniteRelIndex ⊤ = H.FiniteIndex | null | false |
Aesop.Frontend.RuleExpr.rec_2 | Aesop.Frontend.RuleExpr | {motive_1 : Aesop.Frontend.RuleExpr → Sort u} →
{motive_2 : Array Aesop.Frontend.RuleExpr → Sort u} →
{motive_3 : List Aesop.Frontend.RuleExpr → Sort u} →
((f : Aesop.Frontend.Feature) →
(children : Array Aesop.Frontend.RuleExpr) →
motive_2 children → motive_1 (Aesop.Frontend.RuleExpr.... | null | false |
ContinuousMap.HomotopyEquiv | Mathlib.Topology.Homotopy.Equiv | (X : Type u) → (Y : Type v) → [TopologicalSpace X] → [TopologicalSpace Y] → Type (max u v) | A homotopy equivalence between topological spaces `X` and `Y` are a pair of functions
`toFun : C(X, Y)` and `invFun : C(Y, X)` such that `toFun.comp invFun` and `invFun.comp toFun`
are both homotopic to corresponding identity maps.
| true |
SimpleGraph.instDecidableEqWalk.decEq._proof_5 | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} (a a_1 a_2 : V) (a_3 : G.Adj a a_2) (a_4 b : G.Walk a_2 a_1),
¬a_4 = b → ¬SimpleGraph.Walk.cons a_3 a_4 = SimpleGraph.Walk.cons a_3 b | null | false |
Lean.Meta.Grind.Arith.CommRing.RingM.Context | Lean.Meta.Tactic.Grind.Arith.CommRing.RingM | Type | null | true |
AddMonoidAlgebra.of'_mul_divOf | Mathlib.Algebra.MonoidAlgebra.Division | ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : AddCommMonoid G] [inst_2 : IsCancelAdd G] (a : G)
(x : AddMonoidAlgebra k G), (AddMonoidAlgebra.of' k G a * x).divOf a = x | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.