name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Combinatorics.SetFamily.Shadow.0.Finset.mem_upShadow_iterate_iff_exists_card._simp_1_4 | Mathlib.Combinatorics.SetFamily.Shadow | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α) (x : α), (s \ t).erase x = s \ insert x t | false |
CategoryTheory.GrothendieckTopology.liftToPlusObjLimitObj._proof_11 | Mathlib.CategoryTheory.Sites.LeftExact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{D : Type u_5} [inst_1 : CategoryTheory.Category.{u_4, u_5} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
[∀ (X : C), Cat... | false |
_private.Init.Data.Iterators.Lemmas.Consumers.Loop.0.Std.Iter.any_toArray._simp_1_1 | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] {it : Std.Iter β},
it.toArray = it.toList.toArray | false |
Subgroup.hasDetPlusMinusOne_iff_abs_det | Mathlib.NumberTheory.ModularForms.ArithmeticSubgroups | ∀ {n : Type u_1} [inst : Fintype n] [inst_1 : DecidableEq n] {R : Type u_2} [inst_2 : CommRing R]
(Γ : Subgroup (GL n R)) [inst_3 : LinearOrder R] [IsOrderedRing R],
Γ.HasDetPlusMinusOne ↔ ∀ {g : GL n R}, g ∈ Γ → |↑(Matrix.GeneralLinearGroup.det g)| = 1 | true |
Ideal.Factors.piQuotientLinearEquiv._proof_4 | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u_2} [inst : CommRing R] (S : Type u_1) [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : IsDedekindDomain S] (p : Ideal R) (hp : Ideal.map (algebraMap R S) p ≠ ⊥),
Function.RightInverse (Ideal.Factors.piQuotientEquiv p hp).invFun (Ideal.Factors.piQuotientEquiv p hp).toFun | false |
_private.Mathlib.CategoryTheory.Topos.Sheaf.0.CategoryTheory.Presheaf.isPullback_χ_truth._simp_1_1 | Mathlib.CategoryTheory.Topos.Sheaf | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∀ (a : α), b) = b | false |
CategoryTheory.Equivalence.congrFullSubcategory_functor | Mathlib.CategoryTheory.ObjectProperty.Equivalence | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{P : CategoryTheory.ObjectProperty C} {Q : CategoryTheory.ObjectProperty D} (e : C ≌ D)
[inst_2 : Q.IsClosedUnderIsomorphisms] (h : Q.inverseImage e.functor = P),
(e.congrFullSubcategory h).functor... | true |
FirstOrder.Language.PartialEquiv.ext_iff | Mathlib.ModelTheory.PartialEquiv | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N]
{f g : L.PartialEquiv M N},
f = g ↔
∃ (h_dom : f.dom = g.dom),
∀ (x : M) (h : x ∈ f.dom), f.cod.subtype (f.toEquiv ⟨x, h⟩) = g.cod.subtype (g.toEquiv ⟨x, ⋯⟩) | true |
Batteries.BinomialHeap.Imp.HeapNode.rec | Batteries.Data.BinomialHeap.Basic | {α : Type u} →
{motive : Batteries.BinomialHeap.Imp.HeapNode α → Sort u_1} →
motive Batteries.BinomialHeap.Imp.HeapNode.nil →
((a : α) →
(child sibling : Batteries.BinomialHeap.Imp.HeapNode α) →
motive child → motive sibling → motive (Batteries.BinomialHeap.Imp.HeapNode.node a child si... | false |
Representation.mapSubmodule._proof_2 | Mathlib.RepresentationTheory.Submodule | ∀ {k : Type u_2} {G : Type u_3} {V : Type u_1} [inst : CommSemiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V), AddMonoidHomClass (V ≃ₗ[k] ρ.asModule) V ρ.asModule | false |
eq_iff_true_of_subsingleton._simp_1 | Mathlib.Tactic.Attr.Core | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | false |
ProbabilityTheory.covariance_map_equiv | Mathlib.Probability.Moments.Covariance | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {Ω' : Type u_2} {mΩ' : MeasurableSpace Ω'} {μ : MeasureTheory.Measure Ω'}
(X Y : Ω → ℝ) (Z : Ω' ≃ᵐ Ω),
ProbabilityTheory.covariance X Y (MeasureTheory.Measure.map (⇑Z) μ) = ProbabilityTheory.covariance (X ∘ ⇑Z) (Y ∘ ⇑Z) μ | true |
Finset.ruzsa_triangle_inequality_sub_add_add | Mathlib.Combinatorics.Additive.PluenneckeRuzsa | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : AddGroup G] (A B C : Finset G),
(A - C).card * B.card ≤ (A + B).card * (C + B).card | true |
CategoryTheory.IsTriangulated.octahedron_axiom | Mathlib.CategoryTheory.Triangulated.Triangulated | ∀ {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}
[self : Catego... | true |
Lean.Server.Test.Runner.processDirective | Lean.Server.Test.Runner | String → String → ℕ → Lean.Server.Test.Runner.RunnerM Unit | true |
SimpleGraph.mk.inj | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} {Adj : V → V → Prop} {symm : autoParam (Symmetric Adj) SimpleGraph.symm._autoParam}
{loopless : autoParam (Std.Irrefl Adj) SimpleGraph.loopless._autoParam} {Adj_1 : V → V → Prop}
{symm_1 : autoParam (Symmetric Adj_1) SimpleGraph.symm._autoParam}
{loopless_1 : autoParam (Std.Irrefl Adj_1) SimpleGrap... | true |
IsSimpleOrder.equivBool._proof_3 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : LE α] [inst_2 : BoundedOrder α] [IsSimpleOrder α] (x : Bool),
(fun x => decide (x = ⊤)) ((fun x => Bool.casesOn x ⊥ ⊤) x) = x | false |
OreLocalization.smul_div_one | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2}
[inst_2 : MulAction R X] {p : R} {r : X} {s : ↥S}, (p /ₒ s) • (r /ₒ 1) = p • r /ₒ s | true |
CategoryTheory.ShortComplex.liftCycles.congr_simp | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) {A : C} (k k_1 : A ⟶ S.X₂) (e_k : k = k_1)
(hk : CategoryTheory.CategoryStruct.comp k S.g = 0) [inst_2 : S.HasLeftHomology],
S.liftCycles k hk = S.liftCycles k_1 ⋯ | true |
Algebra.map_sup | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (S T : Subalgebra R A),
Subalgebra.map f (S ⊔ T) = Subalgebra.map f S ⊔ Subalgebra.map f T | true |
_private.Mathlib.Analysis.BoxIntegral.Partition.Split.0.BoxIntegral.Prepartition.inf_splitMany._simp_1_1 | Mathlib.Analysis.BoxIntegral.Partition.Split | ∀ {α : Type u} [inst : SemilatticeInf α] (a b c : α), a ⊓ (b ⊓ c) = a ⊓ b ⊓ c | false |
Std.ExtHashMap.getD_ofList_of_mem | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{l : List (α × β)} {k k' : α},
(k == k') = true →
∀ {v fallback : β},
List.Pairwise (fun a b => (a.1 == b.1) = false) l → (k, v) ∈ l → (Std.ExtHashMap.ofList l).getD k' fallback = v | true |
Lean.ClosedTermCache.map._default | Lean.Compiler.ClosedTermCache | Lean.PersistentHashMap Lean.Expr Lean.Name | false |
CategoryTheory.Limits.HasBinaryBiproducts.has_binary_biproduct | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} {inst : CategoryTheory.Category.{uC', uC} C} {inst_1 : CategoryTheory.Limits.HasZeroMorphisms C}
[self : CategoryTheory.Limits.HasBinaryBiproducts C] (P Q : C), CategoryTheory.Limits.HasBinaryBiproduct P Q | true |
Finset.Ioc_ofNat_ofNat | Mathlib.Tactic.Simproc.FinsetInterval | Lean.Meta.Simp.Simproc | true |
_private.Lean.Data.Lsp.Ipc.0.Lean.Lsp.Ipc.waitForILeans.match_1 | Lean.Data.Lsp.Ipc | (motive : Lean.JsonRpc.Message → Sort u_1) →
(__do_lift : Lean.JsonRpc.Message) →
((id : Lean.JsonRpc.RequestID) → (result : Lean.Json) → motive (Lean.JsonRpc.Message.response id result)) →
((id : Lean.JsonRpc.RequestID) →
(code : Lean.JsonRpc.ErrorCode) →
(msg : String) →
... | false |
_private.Mathlib.Tactic.Linter.UnusedTactic.0.Mathlib.Linter.UnusedTactic.getNames | Mathlib.Tactic.Linter.UnusedTactic | Lean.MetavarContext → List Lean.Name | true |
OrderedFinpartition.compAlongOrderedFinpartitionL._proof_2 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] (E : Type u_4) [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] (F : Type u_2) [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (G : Type u_3)
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ} (c : OrderedFinpartition n)
... | false |
_private.Mathlib.MeasureTheory.Constructions.Polish.Basic.0.MeasureTheory.measurableSet_range_of_continuous_injective._proof_1_6 | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {γ : Type u_1} (b : Set (Set γ)), ∅ ∉ b → ∀ (s : ℕ → ↑b) (n : ℕ), ¬↑(s n) = ∅ | false |
Ideal.mem_span_insert | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Semiring α] {s : Set α} {x y : α},
x ∈ Ideal.span (insert y s) ↔ ∃ a, ∃ z ∈ Ideal.span s, x = a * y + z | true |
IsCovariantDerivativeOn.congr_of_eqOn | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Basic | ∀ {𝕜 : 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_5} [inst_6 : NormedAddCommG... | true |
_private.Mathlib.Topology.Homotopy.Lifting.0.IsLocalHomeomorph.exists_lift_nhds.match_1_7 | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_2} {X : Type u_3} {A : Type u_1} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X]
[inst_2 : TopologicalSpace A] (q : E → OpenPartialHomeomorph E X) (t : ℕ → ↑unitInterval) (n : ℕ) (N : Set A)
(g' : ↑unitInterval × A → E) (e : E) (v : Set A) (ta : ↑unitInterval × A)
(motive :
ta ∈ Set.Ic... | false |
Std.Tactic.BVDecide.BVExpr.decEq._proof_140 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (val : BitVec w),
¬llhs.shiftRight lrhs = Std.Tactic.BVDecide.BVExpr.const val | false |
CategoryTheory.SmallObject.SuccStruct.extendToSucc._proof_9 | Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : LinearOrder J]
[inst_2 : SuccOrder J] {j : J} (hj : ¬IsMax j) (F : CategoryTheory.Functor (↑(Set.Iic j)) C) {X : C}
(τ : F.obj ⟨j, ⋯⟩ ⟶ X) {i₁ i₂ i₃ : ↑(Set.Iic (Order.succ j))} (f : i₁ ⟶ i₂) (g : i₂ ⟶ i₃),
CategoryTheory.Smal... | false |
_private.Lean.Elab.PreDefinition.Basic.0.Lean.Elab.addNonRecAux | Lean.Elab.PreDefinition.Basic | Lean.LocalContext × Lean.LocalInstances →
Lean.Elab.PreDefinition →
Bool →
List Lean.Name →
optParam Bool true → optParam Bool true → optParam Bool false → optParam Bool false → Lean.Elab.TermElabM Unit | true |
Batteries.UnionFind.mk.congr_simp | Batteries.Data.UnionFind.Basic | ∀ (arr arr_1 : Array Batteries.UFNode) (e_arr : arr = arr_1)
(parentD_lt : ∀ {i : ℕ}, i < arr.size → Batteries.UnionFind.parentD arr i < arr.size)
(rankD_lt :
∀ {i : ℕ},
Batteries.UnionFind.parentD arr i ≠ i →
Batteries.UnionFind.rankD arr i < Batteries.UnionFind.rankD arr (Batteries.UnionFind.par... | true |
FirstOrder.Language.Hom.mk.noConfusion | Mathlib.ModelTheory.Basic | {L : FirstOrder.Language} →
{M : Type w} →
{N : Type w'} →
{inst : L.Structure M} →
{inst_1 : L.Structure N} →
{P : Sort u_1} →
{toFun : M → N} →
{map_fun' :
autoParam
(∀ {n : ℕ} (f : L.Functions n) (x : Fin n → M),
... | false |
div_right_comm | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b c : α), a / b / c = a / c / b | true |
IsUltrametricDist.exists_norm_finset_sum_le | Mathlib.Analysis.Normed.Group.Ultra | ∀ {M : Type u_1} {ι : Type u_2} [inst : SeminormedAddCommGroup M] [IsUltrametricDist M] (t : Finset ι) [Nonempty ι]
(f : ι → M), ∃ i, (t.Nonempty → i ∈ t) ∧ ‖∑ j ∈ t, f j‖ ≤ ‖f i‖ | true |
Quotient.hrecOn'_mk'' | Mathlib.Data.Quot | ∀ {α : Sort u_1} {s₁ : Setoid α} {φ : Quotient s₁ → Sort u_5} (f : (a : α) → φ (Quotient.mk'' a))
(c : ∀ (a₁ a₂ : α), a₁ ≈ a₂ → f a₁ ≍ f a₂) (x : α), (Quotient.mk'' x).hrecOn' f c = f x | true |
_private.Mathlib.RepresentationTheory.Intertwining.0.Representation.Equiv.instEquivLike._simp_1 | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Semiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : Module A V] [inst_5 : Module A W]
{ρ : Representation A G V} {σ : Representation A G W} {f g : ρ.IntertwiningMap σ},
(f = g) = (f.toLinearMap = g.to... | false |
SimplexCategoryGenRel.toSimplexCategory_map_σ | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {n : ℕ} (i : Fin (n + 1)),
SimplexCategoryGenRel.toSimplexCategory.map (SimplexCategoryGenRel.σ i) = SimplexCategory.σ i | true |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.sle_iff_rotate_le_rotate._proof_1_14 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (n : ℕ) (x y : BitVec (n + 1)), ¬0 ≤ ↑x.toNat → False | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.clz_eq_zero_iff._simp_1_3 | Init.Data.BitVec.Lemmas | ∀ {a b : ℕ}, (¬a ≤ b) = (b < a) | false |
Std.Net.InterfaceAddress.mk.sizeOf_spec | Std.Net.Addr | ∀ (name : String) (physicalAddress : Std.Net.MACAddr) (isLoopback : Bool) (address netMask : Std.Net.IPAddr),
sizeOf
{ name := name, physicalAddress := physicalAddress, isLoopback := isLoopback, address := address,
netMask := netMask } =
1 + sizeOf name + sizeOf physicalAddress + sizeOf isLoopback +... | true |
_private.Init.Data.String.Slice.0.String.Slice.SplitInclusiveIterator.instIteratorId.match_1.eq_6 | Init.Data.String.Slice | ∀ {ρ : Type} {σ : String.Slice → Type} {pat : ρ} [inst : String.Slice.Pattern.ToForwardSearcher pat σ]
{s : String.Slice}
(motive : Std.IterM Id String.Slice → Std.IterStep (Std.IterM Id String.Slice) String.Slice → Sort u_1)
(it : Std.IterM Id String.Slice) (out : String.Slice)
(h_1 :
(currPos : s.Pos) →
... | true |
LinearMap.IsSymmetric.clm_adjoint_eq | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] {A : E →L[𝕜] E}, (↑A).IsSymmetric → ContinuousLinearMap.adjoint A = A | true |
TopologicalSpace.Opens.inclusionTopIso._proof_3 | Mathlib.Topology.Category.TopCat.Opens | ∀ (X : TopCat),
CategoryTheory.CategoryStruct.comp ⊤.inclusion'
(TopCat.ofHom { toFun := fun x => ⟨x, trivial⟩, continuous_toFun := ⋯ }) =
CategoryTheory.CategoryStruct.id ((TopologicalSpace.Opens.toTopCat X).obj ⊤) | false |
LocallyConvexSpace.sInf | Mathlib.Topology.Algebra.Module.LocallyConvex | ∀ {𝕜 : Type u_2} {E : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] {ts : Set (TopologicalSpace E)}, (∀ t ∈ ts, LocallyConvexSpace 𝕜 E) → LocallyConvexSpace 𝕜 E | true |
AddMonoidHom.toOpposite._proof_1 | 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), AddCommute (f x) (f y)) →
∀ (x y : M), (AddOpposite.op ∘ ⇑f) (x + y) = (AddOpposite.op ∘ ⇑f) x + (AddOpposite.op ∘ ⇑f) y | false |
Lean.Elab.WF.GuessLex.BasicMeasure.ctorIdx | Lean.Elab.PreDefinition.WF.GuessLex | Lean.Elab.WF.GuessLex.BasicMeasure → ℕ | false |
CategoryTheory.SmallObject.πFunctorObj_eq | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C) (κ : Cardinal.{w})
[inst_1 : Fact κ.IsRegular] [inst_2 : OrderBot κ.ord.ToType] [inst_3 : I.IsCardinalForSmallObjectArgument κ] {X Y : C}
(f : X ⟶ Y) (j : κ.ord.ToType),
CategoryTheory.SmallObject.πFunctorObj I.homFam... | true |
CategoryTheory.Limits.isIndObject_colimit | Mathlib.CategoryTheory.Limits.Indization.FilteredColimits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : Type v) [inst_1 : CategoryTheory.SmallCategory I]
[CategoryTheory.IsFiltered I] (F : CategoryTheory.Functor I (CategoryTheory.Functor Cᵒᵖ (Type v))),
(∀ (i : I), CategoryTheory.Limits.IsIndObject (F.obj i)) →
CategoryTheory.Limits.IsIndObject (Catego... | true |
LatticeHom.withBot | Mathlib.Order.Hom.WithTopBot | {α : Type u_1} →
{β : Type u_2} → [inst : Lattice α] → [inst_1 : Lattice β] → LatticeHom α β → LatticeHom (WithBot α) (WithBot β) | true |
ContDiff.fderiv_right | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F} {m n : WithTop ℕ∞},
ContDiff 𝕜 n f → m + 1 ≤ n → ContDiff 𝕜 m (fderiv 𝕜 f) | true |
gaussSum_pow_eq_prod_jacobiSum | Mathlib.NumberTheory.JacobiSum.Basic | ∀ {F : Type u_1} {R : Type u_2} [inst : Fintype F] [inst_1 : Field F] [inst_2 : CommRing R] [IsDomain R]
{χ : MulChar F R} {ψ : AddChar F R},
2 ≤ orderOf χ →
ψ.IsPrimitive →
gaussSum χ ψ ^ orderOf χ = χ (-1) * ↑(Fintype.card F) * ∏ i ∈ Finset.Ico 1 (orderOf χ - 1), jacobiSum χ (χ ^ i) | true |
RingEquiv.prodComm._proof_2 | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_2} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (x y : R × S),
AddEquiv.prodComm.toFun (x + y) = AddEquiv.prodComm.toFun x + AddEquiv.prodComm.toFun y | false |
TopologicalSpace.PositiveCompacts.prod | Mathlib.Topology.Sets.Compacts | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
TopologicalSpace.PositiveCompacts α →
TopologicalSpace.PositiveCompacts β → TopologicalSpace.PositiveCompacts (α × β) | true |
groupHomology.boundariesToCycles₁_apply | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep.{u, u, u} k G} (x : ↥(groupHomology.boundaries₁ A)),
↑((groupHomology.boundariesToCycles₁ A) x) = ↑x | true |
_private.Mathlib.Algebra.Group.Subgroup.Basic.0.AddSubgroup.mem_normalizer_iff_conj_image_eq._simp_1_6 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c | false |
summable_finset_prod_of_summable_norm | Mathlib.Analysis.SpecialFunctions.Log.Summable | ∀ {ι : Type u_1} {R : Type u_2} [inst : NormedCommRing R] [NormOneClass R] {f : ι → R} [CompleteSpace R],
(Summable fun i => ‖f i‖) → Summable fun s => ∏ i ∈ s, f i | true |
exteriorPower.presentation_R | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ (R : Type u) [inst : CommRing R] (n : ℕ) (M : Type u_1) [inst_1 : AddCommGroup M] [inst_2 : Module R M],
(exteriorPower.presentation R n M).R = exteriorPower.presentation.Rels R (Fin n) M | true |
CategoryTheory.Functor.CoconeTypes.postcomp_ι | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} (c : F.CoconeTypes)
{T : Type w₂} (φ : c.pt → T), (c.postcomp φ).ι = fun j => φ ∘ c.ι j | true |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithInitial.opEquiv.match_3.splitter | Mathlib.CategoryTheory.WithTerminal.Basic | (C : Type u_1) →
[inst : CategoryTheory.Category.{u_2, u_1} C] →
(motive : (x y : (CategoryTheory.WithInitial C)ᵒᵖ) → (Opposite.unop y ⟶ Opposite.unop x) → (x ⟶ y) → Sort u_3) →
(x y : (CategoryTheory.WithInitial C)ᵒᵖ) →
(f : Opposite.unop y ⟶ Opposite.unop x) →
(x_1 : x ⟶ y) →
... | true |
Aesop.RuleFilter.matchesBuilder | Aesop.RuleSet.Filter | Aesop.RuleFilter → Aesop.BuilderName → Bool | true |
Unitary.path.congr_simp | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | ∀ {A : Type u_1} [inst : CStarAlgebra A] (u v : ↥(unitary A)) (huv : ‖↑v - ↑u‖ < 2),
Unitary.path u v huv = Unitary.path u v huv | true |
MeasureTheory.IsAddFundamentalDomain.nullMeasurableSet_vadd | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α} [MeasurableConstVAdd G α] [MeasureTheory.VAddInvariantMeasure G α μ],
MeasureTheory.IsAddFundamentalDomain G s μ → ∀ (g : G), MeasureTheory.NullMeasurableSet (g +ᵥ s) μ | true |
Condensed.ofSheafForgetStonean._proof_1 | Mathlib.Condensed.Explicit | ∀ {A : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} A] {FA : A → A → Type u_5} {CA : A → Type u_4}
[inst_1 : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)] [inst_2 : CategoryTheory.ConcreteCategory A FA]
[CategoryTheory.Limits.ReflectsFiniteProducts (CategoryTheory.forget A)] (F : CategoryTheory.Functor Stonea... | false |
_private.Mathlib.Geometry.Manifold.Diffeomorph.0.ModelWithCorners.extChartAt_transContinuousLinearEquiv_target._simp_1_1 | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {α : Sort u_1} {β : Sort u_2} {δ : Sort u_3} (f : β → δ) (g : α → β), (fun x => f (g x)) = f ∘ g | false |
LawfulMonadStateOf.seqLeft_get | Batteries.Control.LawfulMonadState | ∀ {σ : Type u_1} {m : Type u_1 → Type u_2} [inst : Monad m] [inst_1 : MonadStateOf σ m] [LawfulMonadStateOf σ m]
{α : Type u_1} (mx : m α), mx <* get = mx | true |
Module.Presentation.directSum_var | Mathlib.Algebra.Module.Presentation.DirectSum | ∀ {A : Type u} [inst : Ring A] {ι : Type w} [inst_1 : DecidableEq ι] {M : ι → Type v}
[inst_2 : (i : ι) → AddCommGroup (M i)] [inst_3 : (i : ι) → Module A (M i)]
(pres : (i : ι) → Module.Presentation A (M i)) (i : ι) (g : (pres i).G),
(Module.Presentation.directSum pres).var ⟨i, g⟩ = (DirectSum.lof A ι M i) ((pre... | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.rec | Mathlib.NumberTheory.FLT.Three | {K : Type u_1} →
[inst : Field K] →
{ζ : K} →
{hζ : IsPrimitiveRoot ζ 3} →
{motive : FermatLastTheoremForThreeGen.Solution✝ hζ → Sort u} →
((toSolution' : FermatLastTheoremForThreeGen.Solution'✝ hζ) →
(hab :
(hζ.toInteger - 1) ^ 2 ∣
Ferma... | false |
Complex.neg_re_eq_norm._simp_1 | Mathlib.Analysis.Complex.Order | ∀ {z : ℂ}, (-z.re = ‖z‖) = (z ≤ 0) | false |
inseparable_iff_mem_closure | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, Inseparable x y ↔ x ∈ closure {y} ∧ y ∈ closure {x} | true |
_private.Init.Syntax.0.Lean.Syntax.setArgs.match_1 | Init.Syntax | (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)) →
((stx : Lean.Syntax) → motive stx) → motive stx | false |
NonUnitalAlgebra.toTop._proof_2 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (x : A), (NonUnitalAlgHom.id R A) x ∈ ⊤ | false |
Mathlib.Tactic.Translate.elabInsertCast | Mathlib.Tactic.Translate.TagUnfoldBoundary | Lean.Ident → Lean.Term → Mathlib.Tactic.Translate.TranslateData → Lean.Elab.Command.CommandElabM Unit | true |
ProbabilityTheory.IsStable.locally_induction | Mathlib.Probability.Process.LocalProperty | ∀ {ι : Type u_1} {Ω : Type u_2} {E : Type u_3} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω}
[inst : ConditionallyCompleteLinearOrderBot ι] [inst_1 : TopologicalSpace ι] [inst_2 : OrderTopology ι]
{𝓕 : MeasureTheory.Filtration ι mΩ} {X : ι → Ω → E} {p q : (ι → Ω → E) → Prop} [SecondCountableTopology ι]
... | true |
DeltaGenerated.topToDeltaGenerated_obj_toTop_carrier | Mathlib.Topology.Category.DeltaGenerated | ∀ (X : TopCat), ↑(DeltaGenerated.topToDeltaGenerated.obj X).toTop = DeltaGeneratedSpace.of ↑X | true |
Equiv.Perm.cycleOf_ne_one_iff_mem_cycleFactorsFinset | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {g : Equiv.Perm α} {x : α},
g.cycleOf x ≠ 1 ↔ g.cycleOf x ∈ g.cycleFactorsFinset | true |
Algebra.IsSeparable.mk._flat_ctor | Mathlib.FieldTheory.Separable | ∀ {F : Type u_1} {K : Type u_3} [inst : CommRing F] [inst_1 : Ring K] [inst_2 : Algebra F K],
(∀ (x : K), IsSeparable F x) → Algebra.IsSeparable F K | false |
AddEquiv.eq_iff_eq_on_generator | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {G : Type u_2} {G' : Type u_3} [inst : AddGroup G] [inst_1 : AddGroup G'] {g : G},
(∀ (x : G), x ∈ AddSubgroup.zmultiples g) → ∀ (f₁ f₂ : G ≃+ G'), f₁ = f₂ ↔ f₁ g = f₂ g | true |
Set.fintypeImage2 | Mathlib.Data.Finite.Prod | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} →
[DecidableEq γ] →
(f : α → β → γ) →
(s : Set α) → (t : Set β) → [hs : Fintype ↑s] → [ht : Fintype ↑t] → Fintype ↑(Set.image2 f s t) | true |
compl_singleton_mem_nhdsSet_iff | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T1Space X] {x : X} {s : Set X}, {x}ᶜ ∈ nhdsSet s ↔ x ∉ s | true |
unique_unit_speed_on_Icc_zero | Mathlib.Analysis.ConstantSpeed | ∀ {E : Type u_2} [inst : PseudoEMetricSpace E] {f : ℝ → E} {s t : ℝ},
0 ≤ s →
0 ≤ t →
∀ {φ : ℝ → ℝ},
MonotoneOn φ (Set.Icc 0 s) →
φ '' Set.Icc 0 s = Set.Icc 0 t →
HasUnitSpeedOn (f ∘ φ) (Set.Icc 0 s) → HasUnitSpeedOn f (Set.Icc 0 t) → Set.EqOn φ id (Set.Icc 0 s) | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.oppositeLeftAction._proof_19 | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_4) (D : Type u_2) [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] (x : Cᵒᵖ) (x_1 : Dᵒᵖ),
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStr... | false |
AugmentedSimplexCategory.equivAugmentedSimplicialObjectFunctorCompToArrowIso_hom_app_left | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C]
(X : CategoryTheory.Functor AugmentedSimplexCategoryᵒᵖ C),
(AugmentedSimplexCategory.equivAugmentedSimplicialObjectFunctorCompToArrowIso.hom.app X).left =
CategoryTheory.CategoryStruct.id
(X.obj
(match CategoryTheory.WithTerminal.incl.... | true |
Lean.Server.FileWorker.instImpl._@.Lean.Server.FileWorker.InlayHints.3310298766._hygCtx._hyg.16 | Lean.Server.FileWorker.InlayHints | TypeName Lean.Server.FileWorker.InlayHintState | false |
Lean.Parser.Term.arrow.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | true |
CategoryTheory.epi_comp_iff_of_epi | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Y) [CategoryTheory.Epi f] (g : Y ⟶ Z),
CategoryTheory.Epi (CategoryTheory.CategoryStruct.comp f g) ↔ CategoryTheory.Epi g | true |
String.Slice.Pattern.ToBackwardSearcher.mk | Init.Data.String.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
{σ : outParam (String.Slice → Type)} →
((s : String.Slice) → Std.Iter (String.Slice.Pattern.SearchStep s)) →
String.Slice.Pattern.ToBackwardSearcher pat σ | true |
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.toSheafedSpaceHom | Mathlib.Geometry.RingedSpace.OpenImmersion | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : AlgebraicGeometry.PresheafedSpace C} →
(Y : AlgebraicGeometry.SheafedSpace C) →
(f : X ⟶ Y.toPresheafedSpace) →
[H : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f] →
AlgebraicGeometry.PresheafedSpace.IsOpenIm... | true |
NonUnitalStarAlgHom.prod._proof_1 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_3} {A : Type u_4} {B : Type u_1} {C : Type u_2} [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : Star A] [inst_4 : NonUnitalNonAssocSemiring B]
[inst_5 : DistribMulAction R B] [inst_6 : Star B] [inst_7 : NonUnitalNonAssocSemiring C]
[inst_8 : Distrib... | false |
SimpleGraph.instDecidableMemSupp | Mathlib.Combinatorics.SimpleGraph.Connectivity.Finite | {V : Type u} →
(G : SimpleGraph V) →
[DecidableEq V] → [Fintype V] → [DecidableRel G.Adj] → (c : G.ConnectedComponent) → (v : V) → Decidable (v ∈ c.supp) | true |
Std.Http.Extensions.compareName._unsafe_rec | Std.Internal.Http.Data.Extensions | Lean.Name → Lean.Name → Ordering | false |
_private.Std.Internal.Async.Signal.0.Std.Internal.IO.Async.Signal.Waiter.ofNative | Std.Internal.Async.Signal | Std.Internal.UV.Signal → Std.Internal.IO.Async.Signal.Waiter | true |
ProbabilityTheory.condIndepFun_iff_condIndepSet_preimage | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {β : Type u_3} {β' : Type u_4} {m' mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω]
{hm' : m' ≤ mΩ} {μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {f : Ω → β} {g : Ω → β'}
{mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'},
Measurable f →
Measurable g →
(... | true |
Pi.constRingHom_apply | Mathlib.Algebra.Ring.Pi | ∀ (α : Type u_1) (β : Type u_2) [inst : NonAssocSemiring β] (a : β) (a_1 : α),
(Pi.constRingHom α β) a a_1 = Function.const α a a_1 | true |
Lean.Syntax.missing | Init.Prelude | Lean.Syntax | true |
Lean.Meta.Grind.Arith.CommRing.EqCnstrProof.div | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ℤ → Lean.Meta.Grind.Arith.CommRing.EqCnstr → Lean.Meta.Grind.Arith.CommRing.EqCnstrProof | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.