name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Algebra.norm_one_add_smul | Mathlib.RingTheory.NormTrace | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [Module.Free A B]
[Module.Finite A B] (a : A) (x : B), ∃ r, (Algebra.norm A) (1 + a • x) = 1 + (Algebra.trace A B) x * a + r * a ^ 2 | true |
_private.Mathlib.NumberTheory.SmoothNumbers.0.Nat.smoothNumbersUpTo_subset_image._simp_1_1 | Mathlib.NumberTheory.SmoothNumbers | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | false |
RootPairing.pairing_smul_root_eq | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) (i j k : ι),
P.reflectionPerm i = P.reflectionPerm j → P.pairing k i • P.root i = P.pairing k j • P.root j | true |
ContDiffWithinAt.comp_contMDiffWithinAt | Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F : Type u_6} [inst_6 : NormedAddCommG... | true |
List.prefix_nil | Init.Data.List.Sublist | ∀ {α : Type u_1} {l : List α}, l <+: [] ↔ l = [] | true |
ChartedSpaceCore.open_target | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {H : Type u} {M : Type u_2} [inst : TopologicalSpace H] (c : ChartedSpaceCore H M) {e : PartialEquiv M H},
e ∈ c.atlas → IsOpen e.target | true |
CircularOrder.recOn | Mathlib.Order.Circular | {α : Type u_1} →
{motive : CircularOrder α → Sort u} →
(t : CircularOrder α) →
([toCircularPartialOrder : CircularPartialOrder α] →
(btw_total : ∀ (a b c : α), btw a b c ∨ btw c b a) →
motive { toCircularPartialOrder := toCircularPartialOrder, btw_total := btw_total }) →
motive... | false |
CategoryTheory.ObjectProperty.whiskerLeft_def | Mathlib.CategoryTheory.Monoidal.Subcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C) [inst_2 : P.IsMonoidal] (X x x_1 : P.FullSubcategory) (f : x ⟶ x_1),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f =
CategoryTheory.ObjectProperty.homMk (CategoryTh... | true |
Std.Internal.List.getEntry?_filter_containsKey_of_containsKey_eq_false_left | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((a : α) × β a)} {k : α},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₁ = false →
Std.Internal.List.getEntry? k (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁) = none | true |
CategoryTheory.Triangulated.TStructure.instIsLEObjTruncGT | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | true |
IntermediateField.gi._proof_2 | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] (S : IntermediateField F E),
↑S ≤ ↑(IntermediateField.adjoin F ↑S) | false |
_private.Lean.Meta.Tactic.Grind.EMatchAction.0.Lean.Meta.Grind.Action.CollectState.visited | Lean.Meta.Tactic.Grind.EMatchAction | Lean.Meta.Grind.Action.CollectState✝ → Std.HashSet Lean.Meta.Sym.ExprPtr | true |
NumberField.of_tower | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) (L : Type u_2) [inst : Field K] [inst_1 : Field L] [NumberField K] [NumberField L]
[inst_4 : Algebra K L] (E : Type u_3) [inst_5 : Field E] [inst_6 : Algebra K E] [inst_7 : Algebra E L]
[IsScalarTower K E L], NumberField E | true |
exists_lt_of_lt_csSup' | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrderBot α] {s : Set α} {a : α}, a < sSup s → ∃ b ∈ s, a < b | true |
Ordnode.splitMin_eq | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (s : ℕ) (l : Ordnode α) (x : α) (r : Ordnode α),
l.splitMin' x r = (l.findMin' x, (Ordnode.node s l x r).eraseMin) | true |
ContinuousMap.setOfIdeal_open | Mathlib.Topology.ContinuousMap.Ideals | ∀ {X : Type u_1} {R : Type u_2} [inst : TopologicalSpace X] [inst_1 : Semiring R] [inst_2 : TopologicalSpace R]
[inst_3 : IsTopologicalSemiring R] [T2Space R] (I : Ideal C(X, R)), IsOpen (ContinuousMap.setOfIdeal I) | true |
Lean.Compiler.LCNF.LambdaLifting.State.mk.noConfusion | Lean.Compiler.LCNF.LambdaLifting | {P : Sort u} →
{decls : Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)} →
{nextIdx : ℕ} →
{decls' : Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)} →
{nextIdx' : ℕ} →
{ decls := decls, nextIdx := nextIdx } = { decls := decls', nextIdx := nextIdx' } →
... | false |
Ultrafilter.mem_pure._simp_1 | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u} {a : α} {s : Set α}, (s ∈ pure a) = (a ∈ s) | false |
_private.Std.Data.DHashMap.Internal.RawLemmas.0.Std.DHashMap.Internal.Raw₀.Const.find?_toArray_eq_none_iff_contains_eq_false._simp_1_2 | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α],
(↑m).WF →
∀ {k : α}, (List.find? (fun x => x.1 == k) (Std.DHashMap.Raw.Const.toList ↑m) = none) = (m.contains k = false) | false |
εNFA.toNFA_evalFrom_match | Mathlib.Computability.EpsilonNFA | ∀ {α : Type u} {σ : Type v} (M : εNFA α σ) (start : Set σ), M.toNFA.evalFrom (M.εClosure start) = M.evalFrom start | true |
CategoryTheory.Adjunction.counit | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} → (F ⊣ G) → (G.comp F ⟶ CategoryTheory.Functor.id D) | true |
CategoryTheory.exactPairingUnit | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.ExactPairing (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C) | true |
Std.DTreeMap.Raw.get?_inter_of_not_mem_left | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp], t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₁ → (t₁ ∩ t₂).get? k = none | true |
AlgebraicGeometry.QuasiCompact | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | {X Y : AlgebraicGeometry.Scheme} → (X ⟶ Y) → Prop | true |
instAddCommMonoidWithOneENNReal | Mathlib.Data.ENNReal.Basic | AddCommMonoidWithOne ENNReal | true |
segment_translate_image | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [AddRightMono 𝕜] [inst_3 : AddCommGroup E]
[inst_4 : Module 𝕜 E] (a b c : E), (fun x => a + x) '' segment 𝕜 b c = segment 𝕜 (a + b) (a + c) | true |
_private.Mathlib.FieldTheory.Minpoly.ConjRootClass.0.ConjRootClass.instFintypeElemCarrierOfNormalOfDecidableEqOfAlgEquiv._simp_2 | Mathlib.FieldTheory.Minpoly.ConjRootClass | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {x y : L},
IsConjRoot K x y = (ConjRootClass.mk K x = ConjRootClass.mk K y) | false |
Prod.mk_left_inj | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b : β}, (a₁, b) = (a₂, b) ↔ a₁ = a₂ | true |
Algebra.adjoin_nonUnitalSubalgebra_eq_span | Mathlib.RingTheory.Adjoin.Basic | ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
(s : NonUnitalSubalgebra R A), Subalgebra.toSubmodule (Algebra.adjoin R ↑s) = R ∙ 1 ⊔ s.toSubmodule | true |
AddSubgroup.opEquiv | Mathlib.Algebra.Group.Subgroup.MulOpposite | {G : Type u_2} → [inst : AddGroup G] → AddSubgroup G ≃o AddSubgroup Gᵃᵒᵖ | true |
Graph.mem_loopSet | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {G : Graph α β} (x : α) (e : β), e ∈ Graph.loopSet x ↔ G.IsLoopAt e x | true |
analyticOrderAt_neg | Mathlib.Analysis.Analytic.Order | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {z₀ : 𝕜}, analyticOrderAt (-f) z₀ = analyticOrderAt f z₀ | true |
Lean.Elab.HoverableInfoPrio.size | Lean.Server.InfoUtils | Lean.Elab.HoverableInfoPrio → ℕ | true |
Lean.Parser.Term.let._regBuiltin.Lean.Parser.Term.let_1 | Lean.Parser.Term | IO Unit | false |
SmoothBumpCovering.apply_ind | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {ι : Type uι} {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type uH}
[inst_2 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type uM} [inst_3 : TopologicalSpace M]
[inst_4 : ChartedSpace H M] [inst_5 : FiniteDimensional ℝ E] {s : Set M} (fs : SmoothBumpCovering ι I M s) (x : ... | true |
Mathlib.Tactic.DeprecateTo.renameTheorem | Mathlib.Tactic.DeprecateTo | Lean.TSyntax `ident → Lean.TSyntax `command → Lean.TSyntax `Lean.Parser.Command.declId × Lean.TSyntax `command | true |
AlgebraicGeometry.Scheme.IdealSheafData.mk.inj | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} {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.affin... | true |
Unitary.linearIsometryEquiv_coe_apply | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_5} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H]
[inst_3 : CompleteSpace H] (u : ↥(unitary (H →L[𝕜] H))), ↑(Unitary.linearIsometryEquiv u).toContinuousLinearEquiv = ↑u | true |
MeasureTheory.charFun_map_smul | Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic | ∀ {E : Type u_2} {mE : MeasurableSpace E} {μ : MeasureTheory.Measure E} [inst : SeminormedAddCommGroup E]
[inst_1 : InnerProductSpace ℝ E] [BorelSpace E] (r : ℝ) (t : E),
MeasureTheory.charFun (MeasureTheory.Measure.map (fun x => r • x) μ) t = MeasureTheory.charFun μ (r • t) | true |
SSet.S.subcomplex | Mathlib.AlgebraicTopology.SimplicialSet.Simplices | {X : SSet} → X.S → X.Subcomplex | true |
Lean.Elab.OptionInfo.noConfusion | Lean.Elab.InfoTree.Types | {P : Sort u} → {t t' : Lean.Elab.OptionInfo} → t = t' → Lean.Elab.OptionInfo.noConfusionType P t t' | false |
LowerSet.instMulAction._proof_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : Preorder α], Function.Injective SetLike.coe | false |
Cardinal.continuum_le_lift._simp_1 | Mathlib.SetTheory.Cardinal.Continuum | ∀ {c : Cardinal.{u}}, (Cardinal.continuum ≤ Cardinal.lift.{v, u} c) = (Cardinal.continuum ≤ c) | false |
_private.Mathlib.Algebra.Homology.Embedding.Connect.0.CochainComplex.ConnectData.d.match_1.eq_4 | Mathlib.Algebra.Homology.Embedding.Connect | ∀ (motive : ℤ → ℤ → Sort u_1) (a a_1 : ℕ) (h_1 : (n m : ℕ) → motive (Int.ofNat n) (Int.ofNat m))
(h_2 : (n m : ℕ) → motive (Int.negSucc n) (Int.negSucc m)) (h_3 : Unit → motive (Int.negSucc 0) (Int.ofNat 0))
(h_4 : (a a_2 : ℕ) → motive (Int.ofNat a) (Int.negSucc a_2))
(h_5 : (a a_2 : ℕ) → motive (Int.negSucc a) (... | true |
IsUnit.mul | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : Monoid M] {a b : M}, IsUnit a → IsUnit b → IsUnit (a * b) | true |
AddHom.prod_map_comap_prod' | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] {M' : Type u_5} {N' : Type u_6} [inst_2 : Add M']
[inst_3 : Add N'] (f : M →ₙ+ N) (g : M' →ₙ+ N') (S : AddSubsemigroup N) (S' : AddSubsemigroup N'),
AddSubsemigroup.comap (f.prodMap g) (S.prod S') = (AddSubsemigroup.comap f S).prod (AddSubsemigroup.com... | true |
Lean.Lsp.CompletionItem.getFileSource! | Lean.Server.FileSource | Lean.Lsp.CompletionItem → Lean.Lsp.DocumentUri | true |
ProbabilityTheory.IndepFun.eq_1 | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {β : Type u_6} {γ : Type u_7} {_mΩ : MeasurableSpace Ω} [inst : MeasurableSpace β]
[inst_1 : MeasurableSpace γ] (f : Ω → β) (g : Ω → γ) (μ : MeasureTheory.Measure Ω),
ProbabilityTheory.IndepFun f g μ =
ProbabilityTheory.Kernel.IndepFun f g (ProbabilityTheory.Kernel.const Unit μ) (MeasureTheory.... | true |
Finset.unop_sum | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddCommMonoid M] (s : Finset ι) (f : ι → Mᵐᵒᵖ),
MulOpposite.unop (∑ x ∈ s, f x) = ∑ x ∈ s, MulOpposite.unop (f x) | true |
List.all_flatten | Init.Data.List.Lemmas | ∀ {α : Type u_1} {f : α → Bool} {l : List (List α)}, l.flatten.all f = l.all fun x => x.all f | true |
ArithmeticFunction.IsMultiplicative.multiplicative_factorization | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] (f : ArithmeticFunction R),
f.IsMultiplicative → ∀ {n : ℕ}, n ≠ 0 → f n = n.factorization.prod fun p k => f (p ^ k) | true |
_private.Init.Data.Array.Lemmas.0.Array.forIn'.loop.match_3.eq_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (as : Array α) (motive : (i : ℕ) → i ≤ as.size → Sort u_2) (x : 0 ≤ as.size)
(h_1 : (x : 0 ≤ as.size) → motive 0 x) (h_2 : (i : ℕ) → (h : i + 1 ≤ as.size) → motive i.succ h),
(match 0, x with
| 0, x => h_1 x
| i.succ, h => h_2 i h) =
h_1 x | true |
Matrix.blockDiagonal_conjTranspose | Mathlib.Data.Matrix.Block | ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} [inst : DecidableEq o] {α : Type u_14} [inst_1 : AddMonoid α]
[inst_2 : StarAddMonoid α] (M : o → Matrix m n α),
(Matrix.blockDiagonal M).conjTranspose = Matrix.blockDiagonal fun k => (M k).conjTranspose | true |
Std.DTreeMap.Internal.Impl.WF.inter! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} [Std.TransOrd α] {m₁ m₂ : Std.DTreeMap.Internal.Impl α β},
m₁.WF → (m₁.inter! m₂).WF | true |
Batteries.Tactic.CollectOpaques.collect | Batteries.Tactic.PrintOpaques | Lean.Name → Batteries.Tactic.CollectOpaques.M Unit | true |
_private.Mathlib.Analysis.Convex.BetweenList.0.List.sbtw_triple._simp_1_3 | Mathlib.Analysis.Convex.BetweenList | ∀ {α : Type u_1} {b : α} {l : List α} {a : α}, (a ∈ b :: l) = (a = b ∨ a ∈ l) | false |
CategoryTheory.IsIso.inv_eq_of_inv_hom_id | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : Y ⟶ X} [inst_1 : CategoryTheory.IsIso f]
{g : X ⟶ Y}, CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.id X → CategoryTheory.inv f = g | true |
Aesop.OrderedHashSet.ctorIdx | Aesop.Util.OrderedHashSet | {α : Type u_1} → {inst : BEq α} → {inst_1 : Hashable α} → Aesop.OrderedHashSet α → ℕ | false |
_private.Mathlib.Tactic.Widget.LibraryRewrite.0.Mathlib.Tactic.LibraryRewrite.rpc.match_1 | Mathlib.Tactic.Widget.LibraryRewrite | (motive : Lean.SubExpr.GoalLocation → Sort u_1) →
(x : Lean.SubExpr.GoalLocation) →
((a : Lean.FVarId) → (a_1 : Lean.SubExpr.Pos) → motive (Lean.SubExpr.GoalLocation.hypValue a a_1)) →
((x : Lean.SubExpr.GoalLocation) → motive x) → motive x | false |
DivisibleHull.mk_eq_mk | Mathlib.GroupTheory.DivisibleHull | ∀ {M : Type u_1} [inst : AddCommMonoid M] {m m' : M} {s s' : ℕ+},
DivisibleHull.mk m s = DivisibleHull.mk m' s' ↔ ∃ u, ↑u • ↑s' • m = ↑u • ↑s • m' | true |
Dvd.elim | Mathlib.Algebra.Divisibility.Basic | ∀ {α : Type u_1} [inst : Semigroup α] {P : Prop} {a b : α}, a ∣ b → (∀ (c : α), b = a * c → P) → P | true |
Vector.toArray_swapAt! | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} {x : α},
((xs.swapAt! i x).1, (xs.swapAt! i x).2.toArray) = ((xs.toArray.swapAt! i x).1, (xs.toArray.swapAt! i x).2) | true |
NonUnitalNonAssocCommSemiring.ext | Mathlib.Algebra.Ring.Ext | ∀ {R : Type u} ⦃inst₁ inst₂ : NonUnitalNonAssocCommSemiring R⦄,
HAdd.hAdd = HAdd.hAdd → HMul.hMul = HMul.hMul → inst₁ = inst₂ | true |
Lean.Elab.Tactic.BVDecide.Frontend.ReflectionResult.casesOn | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide | {motive : Lean.Elab.Tactic.BVDecide.Frontend.ReflectionResult → Sort u} →
(t : Lean.Elab.Tactic.BVDecide.Frontend.ReflectionResult) →
((bvExpr : Std.Tactic.BVDecide.BVLogicalExpr) →
(proveFalse : Lean.Expr → Lean.Elab.Tactic.BVDecide.Frontend.M Lean.Expr) →
(unusedHypotheses : Std.HashSet Lean.F... | false |
CategoryTheory.Triangulated.SpectralObject.Hom.ext_iff | Mathlib.CategoryTheory.Triangulated.SpectralObject | ∀ {C : Type u_1} {ι : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} C}
{inst_1 : CategoryTheory.Category.{v_2, u_2} ι} {inst_2 : CategoryTheory.Limits.HasZeroObject C}
{inst_3 : CategoryTheory.HasShift C ℤ} {inst_4 : CategoryTheory.Preadditive C}
{inst_5 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Addit... | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformFun.uniformSpace_eq_iInf_precomp_of_cover.match_1_1 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_2} (β : Type u_1) {ι : Type u_3} {δ : ι → Type u_4} (φ : (i : ι) → δ i → α) (I : Set ι) (U : Set (β × β))
(motive :
(x : UniformFun α β × UniformFun α β) →
x ∈
⋂ i,
Prod.map (⇑UniformFun.ofFun ∘ (fun x => x ∘ φ ↑i) ∘ ⇑UniformFun.toFun)
(⇑UniformFun.ofFun ∘... | false |
CategoryTheory.ShortComplex.SnakeInput.δ_apply | Mathlib.Algebra.Homology.ShortComplex.ConcreteCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type v}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC]
[inst_3 : CategoryTheory.HasForget₂ C Ab] [inst_4 : CategoryTheory.Abelian C]
[inst_5 : (CategoryTheory.forget₂ C... | true |
Set.Ici_inj | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, Set.Ici a = Set.Ici b ↔ a = b | true |
Function.Surjective.semiring._proof_2 | Mathlib.Algebra.Ring.InjSurj | ∀ {R : Type u_2} {S : Type u_1} (f : R → S) (hf : Function.Surjective f) [inst : Mul S] [inst_1 : Zero S]
[inst_2 : One S] [inst_3 : Pow S ℕ] [inst_4 : Semiring R] (zero : f 0 = 0) (one : f 1 = 1)
(mul : ∀ (x y : R), f (x * y) = f x * f y) (npow : ∀ (x : R) (n : ℕ), f (x ^ n) = f x ^ n) (n : ℕ) (x : S),
Monoid.np... | false |
Matroid.ofExistsFiniteIsBase._proof_4 | Mathlib.Combinatorics.Matroid.IndepAxioms | ∀ {α : Type u_1} (E : Set α) (IsBase : Set α → Prop),
(∃ B, IsBase B ∧ B.Finite) →
Matroid.ExchangeProperty IsBase → ∀ X ⊆ E, Matroid.ExistsMaximalSubsetProperty (fun x => ∃ B, IsBase B ∧ x ⊆ B) X | false |
RingHom.locally_iff_finite | Mathlib.RingTheory.RingHom.Locally | ∀ (P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) {R S : Type u}
[inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S),
RingHom.Locally (fun {R S} [CommRing R] [CommRing S] => P) f ↔
∃ s, ∃ (_ : Ideal.span ↑s = ⊤), ∀ t ∈ s, P ((algebraMap S (Localization.Away t)).comp f) | true |
_private.Mathlib.NumberTheory.WellApproximable.0.AddCircle.addWellApproximable_ae_empty_or_univ._simp_1_3 | Mathlib.NumberTheory.WellApproximable | ∀ {α : Type u}, (fun x1 x2 => x1 ∪ x2) = fun x1 x2 => x1 ⊔ x2 | false |
NNDist.casesOn | Mathlib.Topology.MetricSpace.Pseudo.Defs | {α : Type u_3} →
{motive : NNDist α → Sort u} → (t : NNDist α) → ((nndist : α → α → NNReal) → motive { nndist := nndist }) → motive t | false |
_private.Mathlib.Data.Analysis.Filter.0.Filter.Realizer.map._simp_3 | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_1} {f : Filter α} {s : Set α}, (s ∈ f.sets) = (s ∈ f) | false |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.expandCDot?.go.match_3 | Lean.Elab.BuiltinNotation | (motive : Lean.Syntax → Sort u_1) →
(stx : Lean.Syntax) →
((info : Lean.SourceInfo) →
(k : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive (Lean.Syntax.node info k args)) →
((x : Lean.Syntax) → motive x) → motive stx | false |
Lean.MetavarContext.MkBinding.Context.binderInfoForMVars | Lean.MetavarContext | Lean.MetavarContext.MkBinding.Context → Lean.BinderInfo | true |
Lean.Grind.Semiring.mul_one | Init.Grind.Ring.Basic | ∀ {α : Type u} [self : Lean.Grind.Semiring α] (a : α), a * 1 = a | true |
SimpleGraph.IsContained.lineGraph | Mathlib.Combinatorics.SimpleGraph.LineGraph | ∀ {V : Type u_1} {V' : Type u_2} {G : SimpleGraph V} {G' : SimpleGraph V'},
G.IsContained G' → G.lineGraph.IsContained G'.lineGraph | true |
_private.Mathlib.Algebra.GroupWithZero.Basic.0.IsNilpotent.pow_succ.match_1_1 | Mathlib.Algebra.GroupWithZero.Basic | ∀ {S : Type u_1} [inst : MonoidWithZero S] {x : S} (motive : IsNilpotent x → Prop) (hx : IsNilpotent x),
(∀ (N : ℕ) (hN : x ^ N = 0), motive ⋯) → motive hx | false |
Float32.mk | Init.Data.Float32 | float32Spec.float → Float32 | true |
_private.Batteries.Tactic.HelpCmd.0.Batteries.Tactic.elabHelpCats.match_1 | Batteries.Tactic.HelpCmd | (motive : Lean.Name × Lean.Parser.ParserCategory → Sort u_1) →
(x : Lean.Name × Lean.Parser.ParserCategory) →
((name : Lean.Name) → (cat : Lean.Parser.ParserCategory) → motive (name, cat)) → motive x | false |
MeasureTheory.Measure.AbsolutelyContinuous.null_mono | Mathlib.MeasureTheory.Measure.AbsolutelyContinuous | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
μ.AbsolutelyContinuous ν → ∀ ⦃t : Set α⦄, ν t = 0 → μ t = 0 | true |
Submonoid.ext | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : MulOneClass M] {S T : Submonoid M}, (∀ (x : M), x ∈ S ↔ x ∈ T) → S = T | true |
Lean.Compiler.specializeAttr._regBuiltin.Lean.Compiler.specializeAttr.declRange_3 | Lean.Compiler.Specialize | IO Unit | false |
ConGen.Rel | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_1} → [Mul M] → (M → M → Prop) → M → M → Prop | true |
LinearEquiv.mapMatrix._proof_2 | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_1} {n : Type u_2} {R : Type u_5} {S : Type u_6} {α : Type u_3} {β : Type u_4} [inst : Semiring R]
[inst_1 : Semiring S] [inst_2 : AddCommMonoid α] [inst_3 : AddCommMonoid β] [inst_4 : Module R α]
[inst_5 : Module S β] {σᵣₛ : R →+* S} {σₛᵣ : S →+* R} [inst_6 : RingHomInvPair σᵣₛ σₛᵣ]
[inst_7 : RingHo... | false |
_private.Mathlib.MeasureTheory.Integral.IntegralEqImproper.0.MeasureTheory.tendsto_limUnder_of_hasDerivAt_of_integrableOn_Ioi._simp_1_2 | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ici b) = (b ≤ x) | false |
Plausible.SampleableExt.noConfusionType | Plausible.Sampleable | Sort u_1 → {α : Sort u} → Plausible.SampleableExt α → {α' : Sort u} → Plausible.SampleableExt α' → Sort u_1 | false |
CategoryTheory.NatTrans.removeRightOp | Mathlib.CategoryTheory.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F G : CategoryTheory.Functor Cᵒᵖ D} → (F.rightOp ⟶ G.rightOp) → (G ⟶ F) | true |
SheafOfModules.pushforwardOver.eq_1 | Mathlib.Algebra.Category.ModuleCat.Sheaf.PushforwardContinuous | ∀ {C : Type u'} [inst : CategoryTheory.Category.{v', u'} C] [inst_1 : CategoryTheory.Limits.HasBinaryProducts C]
{J : CategoryTheory.GrothendieckTopology C} {R : CategoryTheory.Sheaf J RingCat} (x : C),
SheafOfModules.pushforwardOver x =
{ hom := { app := fun U => R.obj.map CategoryTheory.Limits.prod.snd.op, na... | true |
WithTop.untopA.eq_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : Nonempty α], WithTop.untopA = WithTop.untopD (Classical.arbitrary α) | true |
AlgebraicGeometry.Scheme.isoOfEq_hom | Mathlib.AlgebraicGeometry.Restrict | ∀ (X : AlgebraicGeometry.Scheme) {U V : X.Opens} (e : U = V), (X.isoOfEq e).hom = X.homOfLE ⋯ | true |
OnePoint.IsZeroAt.smul_iff | Mathlib.NumberTheory.ModularForms.BoundedAtCusp | ∀ {c : OnePoint ℝ} {f : UpperHalfPlane → ℂ} {k : ℤ} {g : GL (Fin 2) ℝ},
(g • c).IsZeroAt f k ↔ c.IsZeroAt (SlashAction.map k g f) k | true |
CategoryTheory.Functor.instIsHomologicalCompOfIsTriangulated | Mathlib.CategoryTheory.Triangulated.HomologicalFunctor | ∀ {C : Type u_1} {D : Type u_2} {A : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.HasShift C ℤ] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.Limits.HasZeroObject D] [inst_4 : CategoryTheory.HasShift D ℤ]
[inst_5 : CategoryTheory.Preadditive D] [inst_... | true |
Mathlib.Meta.FunProp.LambdaTheorems | Mathlib.Tactic.FunProp.Theorems | Type | true |
instNonAssocRingWithConvMatrix._proof_3 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {m : Type u_3} {n : Type u_2} {α : Type u_1} [inst : NonAssocRing α] (a : WithConv (Matrix m n α)), 1 * a = a | false |
OrderDual.instPow_1 | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → {β : Type u_2} → [h : Pow α β] → Pow α βᵒᵈ | true |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.simpGoal.match_3 | Lean.Meta.Tactic.Simp.Main | (motive : Option Lean.MVarId × Lean.Meta.Simp.Stats → Sort u_1) →
(__do_lift : Option Lean.MVarId × Lean.Meta.Simp.Stats) →
((stats' : Lean.Meta.Simp.Stats) → motive (none, stats')) →
((mvarIdNew' : Lean.MVarId) → (stats' : Lean.Meta.Simp.Stats) → motive (some mvarIdNew', stats')) →
motive __do_lift | false |
affineHomeomorph._proof_3 | Mathlib.Topology.Algebra.Field | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : TopologicalSpace 𝕜] [IsTopologicalRing 𝕜] (a b : 𝕜),
Continuous fun x => a * x + b | false |
SSet.Truncated.Path₁.arrow_tgt | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ {X : SSet.Truncated 1} {n : ℕ} (self : X.Path₁ n) (i : Fin n),
X.map
(SimplexCategory.Truncated.Hom.tr (SimplexCategory.δ 0) SSet.Truncated.Path₁._proof_1
SSet.Truncated.Path₁._proof_5).op
(self.arrow i) =
self.vertex i.succ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.