name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Function.Injective.coframeMinimalAxioms | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} →
{β : Type v} →
[inst : Max α] →
[inst_1 : Min α] →
[inst_2 : LE α] →
[inst_3 : LT α] →
[inst_4 : SupSet α] →
[inst_5 : InfSet α] →
[inst_6 : Top α] →
[inst_7 : Bot α] →
(minAx : Order.Coframe.Min... | true |
CategoryTheory.Abelian.SpectralObject.δToCycles_cyclesIso_inv_assoc | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {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.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) Categ... | true |
Std.ExtTreeSet.max?_eq_none_iff._simp_1 | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp], (t.max? = none) = (t = ∅) | false |
_private.Mathlib.CategoryTheory.Monoidal.Limits.Cokernels.0.CategoryTheory.Limits.CokernelCofork.tensor._simp_1 | Mathlib.CategoryTheory.Monoidal.Limits.Cokernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {W X Y : C}
(f : W ⟶ X) (g : X ⟶ Y) (Z : C) {Z_1 : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Z)
... | false |
CategoryTheory.TwoSquare.structuredArrowRightwardsOpEquivalence.functor._proof_5 | Mathlib.CategoryTheory.GuitartExact.Opposite | ∀ {C₁ : Type u_8} {C₂ : Type u_4} {C₃ : Type u_6} {C₄ : Type u_2} [inst : CategoryTheory.Category.{u_7, u_8} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_5, u_6} C₃]
[inst_3 : CategoryTheory.Category.{u_1, u_2} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.F... | false |
MonadState.mk | Init.Prelude | {σ : outParam (Type u)} →
{m : Type u → Type v} → m σ → (σ → m PUnit.{u + 1}) → ({α : Type u} → (σ → α × σ) → m α) → MonadState σ m | true |
_private.Mathlib.RingTheory.MvPolynomial.Homogeneous.0.Ideal.span_eq_map_homogeneousSubmodule._simp_1_1 | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range (g ∘ f) | false |
CategoryTheory.Cat.Hom.toNatIso._proof_2 | Mathlib.CategoryTheory.Category.Cat | ∀ {X Y : CategoryTheory.Cat} {F G : X ⟶ Y} (e : F ≅ G),
{ toNatTrans := CategoryTheory.CategoryStruct.comp e.inv.toNatTrans e.hom.toNatTrans }.toNatTrans =
{ toNatTrans := CategoryTheory.CategoryStruct.id G.toFunctor }.toNatTrans | false |
DirectSum.gMulLHom._proof_3 | Mathlib.Algebra.DirectSum.Algebra | ∀ {ι : Type u_3} (R : Type u_1) (A : ι → Type u_2) [inst : CommSemiring R] [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : (i : ι) → Module R (A i)] [inst_3 : AddMonoid ι] {i j : ι}, SMulCommClass R R (A (i + j)) | false |
_private.Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv.0.GenContFract.squashSeq.match_1.splitter | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | {K : Type u_1} →
(motive : Option (GenContFract.Pair K) × Option (GenContFract.Pair K) → Sort u_2) →
(x : Option (GenContFract.Pair K) × Option (GenContFract.Pair K)) →
((gp_n gp_succ_n : GenContFract.Pair K) → motive (some gp_n, some gp_succ_n)) →
((x : Option (GenContFract.Pair K) × Option (GenCon... | true |
QuadraticAlgebra.instAddCommGroupWithOne._proof_2 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : AddCommGroupWithOne R] (n : ℕ), QuadraticAlgebra.C ↑(Int.negSucc n) = -↑(n + 1) | false |
LieAlgebra.LieEquiv.ofCoboundary._proof_5 | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_3} {L : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
(c c' : ↥(LieModule.Cohomology.twoCocycle R L M)) (x : LieModule.Cohomology.oneCochain R L M),
↑... | false |
List.reverse_ne_nil_iff | Init.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α}, xs.reverse ≠ [] ↔ xs ≠ [] | true |
Lean.Compiler.LCNF.TrivialStructureInfo.noConfusion | Lean.Compiler.LCNF.Irrelevant | {P : Sort u} →
{t t' : Lean.Compiler.LCNF.TrivialStructureInfo} →
t = t' → Lean.Compiler.LCNF.TrivialStructureInfo.noConfusionType P t t' | false |
nilpotencyClass_zero_iff_subsingleton | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] [Group.IsNilpotent G], Group.nilpotencyClass G = 0 ↔ Subsingleton G | true |
_private.Mathlib.Combinatorics.Additive.FreimanHom.0.isMulFreimanHom_two._simp_1_1 | Mathlib.Combinatorics.Additive.FreimanHom | ∀ {α : Type u_1} {s : Multiset α}, (s.card = 2) = ∃ x y, s = {x, y} | false |
instHasLimitsOfSizeLightCondMod | Mathlib.Condensed.Light.Limits | ∀ (R : Type u) [inst : Ring R], CategoryTheory.Limits.HasLimitsOfSize.{u, u, u + 1, u + 1} (LightCondMod R) | true |
CategoryTheory.FreeBicategory.Hom₂.mk | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{a b : CategoryTheory.FreeBicategory B} → {f g : a ⟶ b} → CategoryTheory.FreeBicategory.Hom₂ f g → (f ⟶ g) | true |
_private.Mathlib.Analysis.Convex.Between.0.Wbtw.trans_left_right._simp_1_4 | Mathlib.Analysis.Convex.Between | ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] {g₁ g₂ : G} (p : P),
(g₁ +ᵥ p = g₂ +ᵥ p) = (g₁ = g₂) | false |
Algebra.Generators.ofAlgHom.congr_simp | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {I : Type u_1}
(f f_1 : MvPolynomial I R →ₐ[R] S) (e_f : f = f_1) (h : Function.Surjective ⇑f),
Algebra.Generators.ofAlgHom f h = Algebra.Generators.ofAlgHom f_1 ⋯ | true |
ModuleCat.ExtendRestrictScalarsAdj.Unit.map | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} →
{S : Type u₂} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
(f : R →+* S) → {X : ModuleCat R} → X ⟶ ((ModuleCat.extendScalars f).comp (ModuleCat.restrictScalars f)).obj X | true |
TestFunction.mkCLM.congr_simp | Mathlib.Analysis.Distribution.TestFunction | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_4} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F] {n : ℕ∞} {V : Type u_6} [inst_6 : AddCommGroup V]
[in... | true |
CategoryTheory.HalfBraiding.naturality._autoParam | Mathlib.CategoryTheory.Monoidal.Center | Lean.Syntax | false |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.RCasesPatt.tuple₁Core.match_1 | Lean.Elab.Tactic.RCases | (motive : List Lean.Elab.Tactic.RCases.RCasesPatt → Sort u_1) →
(x : List Lean.Elab.Tactic.RCases.RCasesPatt) →
(Unit → motive []) →
((ref : Lean.Syntax) → motive [Lean.Elab.Tactic.RCases.RCasesPatt.tuple ref []]) →
((ref : Lean.Syntax) →
(ps : List Lean.Elab.Tactic.RCases.RCasesPatt) → ... | false |
Lean.Server.RequestCancellationToken.ctorIdx | Lean.Server.RequestCancellation | Lean.Server.RequestCancellationToken → ℕ | false |
Convex.integral_mem | Mathlib.Analysis.Convex.Integral | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[CompleteSpace E] {μ : MeasureTheory.Measure α} {s : Set E} {f : α → E} [MeasureTheory.IsProbabilityMeasure μ],
Convex ℝ s → IsClosed s → (∀ᵐ (x : α) ∂μ, f x ∈ s) → MeasureTheory.Integrable f μ → ∫ (x :... | true |
UpperHalfPlane.coe_J_smul | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ (τ : UpperHalfPlane), ↑(UpperHalfPlane.J • τ) = -(starRingEnd ℂ) ↑τ | true |
ZFSet.nonempty_of_mem | Mathlib.SetTheory.ZFC.Basic | ∀ {x u : ZFSet.{u_1}}, x ∈ u → u.Nonempty | true |
Equiv.sigmaSubtype._proof_5 | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_2} {β : α → Type u_1} (a : α) (x : { s // s.fst = a }) (a_1 : Sigma β) (h : a_1.fst = a),
(fun b => ⟨⟨a, b⟩, ⋯⟩)
((fun x =>
match x with
| ⟨⟨fst, b⟩, h⟩ => h ▸ b)
⟨a_1, h⟩) =
⟨a_1, h⟩ | false |
finsum_mul' | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {R : Type u_7} [inst : NonUnitalNonAssocSemiring R] (f : α → R) (r : R),
Function.HasFiniteSupport f → (∑ᶠ (a : α), f a) * r = ∑ᶠ (a : α), f a * r | true |
Lean.IR.ExpandResetReuse.reuseToSet._unsafe_rec | Lean.Compiler.IR.ExpandResetReuse | Lean.IR.ExpandResetReuse.Context → Lean.IR.VarId → Lean.IR.VarId → Lean.IR.FnBody → Lean.IR.FnBody | false |
PUnit.mulSemiringAction._proof_1 | Mathlib.Algebra.Module.PUnit | ∀ {R : Type u_2} [inst : Semiring R] (r : R), r • 1 = 1 | false |
_private.Mathlib.CategoryTheory.Functor.TypeValuedFlat.0.CategoryTheory.FunctorToTypes.fromOverFunctorElementsEquivalence._proof_11 | Mathlib.CategoryTheory.Functor.TypeValuedFlat | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor C (Type u_3)) {X : C}
(x : F.obj X) {X_1 Y : CategoryTheory.Over (F.elementsMk X x)} (f : X_1 ⟶ Y),
↑(CategoryTheory.CategoryStruct.comp f.left Y.hom) = ↑X_1.hom | false |
_private.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.quoteSyntax._sparseCasesOn_3 | Lean.Elab.Quotation | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
AlgebraicGeometry.Scheme.Modules.restrictFunctorId_inv_app_app | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X : AlgebraicGeometry.Scheme} {M : X.Modules} {U : X.Opens},
AlgebraicGeometry.Scheme.Modules.Hom.app (AlgebraicGeometry.Scheme.Modules.restrictFunctorId.inv.app M) U =
M.presheaf.map (CategoryTheory.eqToHom ⋯).op | true |
Function.graph | Mathlib.Data.Rel | {α : Type u_1} → {β : Type u_2} → (α → β) → SetRel α β | true |
CategoryTheory.Limits.IsLimit.pushout_zero_ext | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Connected | ∀ {J : Type w} [inst : CategoryTheory.Category.{w', w} J] [CategoryTheory.IsConnected J] {C : Type u}
[inst_2 : CategoryTheory.Category.{v, u} C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_4 : CategoryTheory.Limits.HasPushouts C] [inst_5 : CategoryTheory.Limits.HasLimitsOfShape J C]
[CategoryTheory... | true |
CategoryTheory.Monad.MonadicityInternal.instHasColimitWalkingParallelPairParallelPairMapAppCounitObjOfHasCoequalizerAA | Mathlib.CategoryTheory.Monad.Monadicity | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₁, u₂} D]
{G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D} (adj : F ⊣ G)
[∀ (A : adj.toMonad.Algebra), CategoryTheory.Limits.HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] (B : D)... | true |
Quiver.homOfEq_trans | Mathlib.Combinatorics.Quiver.Basic | ∀ {V : Type u_1} [inst : Quiver V] {X Y X' Y' : V} (f : X ⟶ Y) (hX : X = X') (hY : Y = Y') {X'' Y'' : V}
(hX' : X' = X'') (hY' : Y' = Y''), Quiver.homOfEq (Quiver.homOfEq f hX hY) hX' hY' = Quiver.homOfEq f ⋯ ⋯ | true |
MonCat.monoidObj.eq_1 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J MonCat) (j : J),
MonCat.monoidObj F j = MonCat.monoidObj._aux_1 F j | true |
CategoryTheory.ComposableArrows.naturality'._auto_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | false |
_private.Mathlib.GroupTheory.GroupAction.Primitive.0.MulAction.IsPreprimitive.exists_mem_smul_and_notMem_smul._simp_1_3 | Mathlib.GroupTheory.GroupAction.Primitive | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
String.Slice.Pos.Splits.rec | Init.Data.String.Lemmas.Splits | {s : String.Slice} →
{p : s.Pos} →
{t₁ t₂ : String} →
{motive : p.Splits t₁ t₂ → Sort u} →
((eq_append : s.copy = t₁ ++ t₂) → (offset_eq_rawEndPos : p.offset = t₁.rawEndPos) → motive ⋯) →
(t : p.Splits t₁ t₂) → motive t | false |
Std.TreeSet.Raw.get!_insertMany_list_of_not_mem_of_contains_eq_false | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : BEq α]
[Std.LawfulBEqCmp cmp] [inst_2 : Inhabited α],
t.WF → ∀ {l : List α} {k : α}, k ∉ t → l.contains k = false → (t.insertMany l).get! k = default | true |
String.Pos.Raw.isValidForSlice_iff_exists_append | Init.Data.String.Basic | ∀ {s : String.Slice} {p : String.Pos.Raw},
String.Pos.Raw.IsValidForSlice s p ↔ ∃ t₁ t₂, s.copy = t₁ ++ t₂ ∧ p = t₁.rawEndPos | true |
LinearEquiv.det_baseChange | Mathlib.LinearAlgebra.Charpoly.BaseChange | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Free R M]
[Module.Finite R M] (A : Type u_3) [inst_5 : CommRing A] [inst_6 : Algebra R A] (f : M ≃ₗ[R] M),
LinearEquiv.det (LinearEquiv.baseChange R A M M f) = (Units.map ↑(algebraMap R A)) (LinearEquiv.det f... | true |
_private.Mathlib.Computability.Primrec.List.0.Primrec.list_set.match_1_1 | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} (motive : ℕ × α → Prop) (x : ℕ × α), (∀ (n : ℕ) (v : α), motive (n, v)) → motive x | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_15 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {i : ℕ} (s : ℕ),
i + 1 ≤ (List.findIdxs p (head :: tail) s).length → i < (List.findIdxs p (head :: tail) s).length | false |
Filter.CardinalGenerateSets.below | Mathlib.Order.Filter.CardinalInter | {α : Type u} →
{c : Cardinal.{u}} →
{g : Set (Set α)} →
{motive : (a : Set α) → Filter.CardinalGenerateSets g a → Prop} →
{a : Set α} → Filter.CardinalGenerateSets g a → Prop | true |
MeasureTheory.L1.SimpleFunc.integralCLM'._proof_2 | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ (α : Type u_1) (E : Type u_2) (𝕜 : Type u_3) [inst : NormedAddCommGroup E] {m : MeasurableSpace α}
(μ : MeasureTheory.Measure α) [inst_1 : NormedRing 𝕜] [inst_2 : Module 𝕜 E] [inst_3 : IsBoundedSMul 𝕜 E]
[inst_4 : NormedSpace ℝ E] [inst_5 : SMulCommClass ℝ 𝕜 E] (f : ↥(MeasureTheory.Lp.simpleFunc E 1 μ)),
‖... | false |
CommGroup.torsion.eq_1 | Mathlib.GroupTheory.Torsion | ∀ (G : Type u_1) [inst : CommGroup G], CommGroup.torsion G = { toSubmonoid := CommMonoid.torsion G, inv_mem' := ⋯ } | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.ENNReal.rpow_mul._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {R : Type u} [inst : Semiring R] [inst_1 : PartialOrder R] [ExistsAddOfLE R] [MulPosStrictMono R]
[AddRightStrictMono R] [AddRightReflectLT R] {a b : R}, a < 0 → b < 0 → (0 < a * b) = True | false |
MulEquiv.withZero._proof_2 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_2} {β : Type u_1} [inst : Group α] [inst_1 : Group β] (e : α ≃* β) (x : WithZero β),
(WithZero.map' ↑e) ((WithZero.map' ↑e.symm) x) = x | false |
CategoryTheory.Functor.LaxRightLinear.μᵣ_unitality._autoParam | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | Lean.Syntax | false |
HomologicalComplex.mapBifunctorDesc | Mathlib.Algebra.Homology.Bifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} D] →
{I₁ : Type u_4} →
{I₂ : Type u_5} →
{J : Type... | true |
Lean.Server.Test.Runner.Client.instFromJsonInteractiveTermGoal | Lean.Server.Test.Runner | Lean.FromJson Lean.Server.Test.Runner.Client.InteractiveTermGoal | true |
Std.Time.Day.Ordinal.instInhabitedOfYear._proof_1 | Std.Time.Date.Unit.Day | 1 ≤ 1 | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.insertEntry_perm_filter._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} (a : α) {l₁ l₂ : List α}, (a :: l₁).Perm (a :: l₂) = l₁.Perm l₂ | false |
CategoryTheory.MonoidalCategory.DayConvolution.mk | Mathlib.CategoryTheory.Monoidal.DayConvolution | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
{F G : CategoryTheory.Functor C V} →
(convol... | true |
midpoint_le_right._simp_1 | Mathlib.LinearAlgebra.AffineSpace.Ordered | ∀ {k : Type u_1} {E : Type u_2} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : IsStrictOrderedRing k]
[inst_3 : AddCommGroup E] [inst_4 : PartialOrder E] [IsOrderedAddMonoid E] [inst_6 : Module k E]
[IsStrictOrderedModule k E] [PosSMulReflectLE k E] {a b : E}, (midpoint k a b ≤ b) = (a ≤ b) | false |
AlternatingMap.mkContinuousLinear_norm_le_max | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u} {E : Type wE} {F : Type wF} {G : Type wG} {ι : Type v} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 F] [inst_5 : SeminormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] [inst_7 : Fintype... | true |
CategoryTheory.Limits.KernelFork.mapIsoOfIsLimit_inv | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
{f : X ⟶ Y} {X' Y' : C} {f' : X' ⟶ Y'} {kf : CategoryTheory.Limits.KernelFork f}
{kf' : CategoryTheory.Limits.KernelFork f'} (hf : CategoryTheory.Limits.IsLimit kf)
(hf' : CategoryTheory.Limits.I... | true |
MvPolynomial.bind₂_monomial | Mathlib.Algebra.MvPolynomial.Monad | ∀ {σ : Type u_1} {R : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
(f : R →+* MvPolynomial σ S) (d : σ →₀ ℕ) (r : R),
(MvPolynomial.bind₂ f) ((MvPolynomial.monomial d) r) = f r * (MvPolynomial.monomial d) 1 | true |
isMin_bot | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderBot α], IsMin ⊥ | true |
_private.Lean.Meta.Tactic.Intro.0.Lean.Meta.mkAuxNameImp.match_1 | Lean.Meta.Tactic.Intro | (motive : List Lean.Name → Sort u_1) →
(x : List Lean.Name) →
(Unit → motive []) → ((n : Lean.Name) → (rest : List Lean.Name) → motive (n :: rest)) → motive x | false |
LinearMap.IsSymmetric.diagonalization_apply_self_apply | Mathlib.Analysis.InnerProductSpace.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →ₗ[𝕜] E} [inst_3 : FiniteDimensional 𝕜 E] (hT : T.IsSymmetric) (v : E) (μ : Module.End.Eigenvalues T),
(hT.diagonalization (T v)).ofLp μ = ↑T 1 μ • (hT.diagonalization v).ofLp μ | true |
HeytAlg.instConcreteCategoryHeytingHomCarrier._proof_3 | Mathlib.Order.Category.HeytAlg | ∀ {X : HeytAlg} (x : ↑X), (CategoryTheory.CategoryStruct.id X).hom' x = x | false |
_private.Mathlib.Condensed.Light.EffectiveEpi.0.instIsRegularEpiCategoryLightCondSet._proof_1 | Mathlib.Condensed.Light.EffectiveEpi | CategoryTheory.IsRegularEpiCategory LightCondSet | false |
CategoryTheory.MorphismProperty.Over.pullbackCongr_hom_app_left_fst_assoc | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P Q : CategoryTheory.MorphismProperty T}
[inst_1 : Q.IsMultiplicative] {X Y : T} {f : X ⟶ Y} [inst_2 : P.HasPullbacksAlong f] {g : X ⟶ Y}
[inst_3 : P.IsStableUnderBaseChangeAlong f] [inst_4 : Q.IsStableUnderBaseChange] (h : f = g) (A : P.Over Q Y) {Z :... | true |
Std.TreeSet.mem_insert_self | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k : α}, k ∈ t.insert k | true |
_private.Init.Data.Array.Erase.0.Array.mem_eraseIdx_iff_getElem._simp_1_1 | Init.Data.Array.Erase | ∀ {α : Type u_1} {x : α} {l : List α} {k : ℕ}, (x ∈ l.eraseIdx k) = ∃ i, ∃ (h : i < l.length), i ≠ k ∧ l[i] = x | false |
MeasureTheory.Measure.IsHaarMeasure.mk._flat_ctor | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_3} [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : MeasurableSpace G]
{μ : MeasureTheory.Measure G},
(∀ ⦃K : Set G⦄, IsCompact K → μ K < ⊤) →
(∀ (g : G), MeasureTheory.Measure.map (fun x => g * x) μ = μ) →
(∀ (U : Set G), IsOpen U → U.Nonempty → μ U ≠ 0) → μ.IsHaarMeasure | false |
_private.Mathlib.Algebra.Algebra.Unitization.0.Unitization.isSelfAdjoint_inr._simp_1_1 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} [inst : Star R] {x : R}, IsSelfAdjoint x = (star x = x) | false |
Nat.Partrec.Code.eval_eq_rfindOpt | Mathlib.Computability.PartrecCode | ∀ (c : Nat.Partrec.Code) (n : ℕ), c.eval n = Nat.rfindOpt fun k => Nat.Partrec.Code.evaln k c n | true |
_private.Mathlib.RingTheory.Jacobson.Ring.0.IsLocalization.isMaximal_iff_isMaximal_disjoint._simp_1_2 | Mathlib.RingTheory.Jacobson.Ring | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
SSet.stdSimplex.objMk₁_of_castSucc_lt | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplexOne | ∀ {n : ℕ} (i : Fin (n + 2)) (j : Fin (n + 1)), j.castSucc < i → (SSet.stdSimplex.objMk₁ i) j = 0 | true |
HahnSeries.toIterate._proof_2 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : PartialOrder Γ']
(x : HahnSeries (Lex (Γ × Γ')) R),
(Function.support fun g => { coeff := fun g' => x.coeff (g, g'), isPWO_support' := ⋯ }).IsPWO | false |
Rep.unitIso._proof_5 | Mathlib.RepresentationTheory.Rep.Iso | ∀ {k : Type u_2} {G : Type u_3} [inst : CommRing k] [inst_1 : Monoid G] (V : Rep.{u_1, u_2, u_3} k G),
Function.LeftInverse Rep.unitIsoAddEquiv.invFun Rep.unitIsoAddEquiv.toFun | false |
Matrix.normedAddCommGroup | Mathlib.Analysis.Matrix.Normed | {m : Type u_3} →
{n : Type u_4} →
{α : Type u_5} → [Fintype m] → [Fintype n] → [NormedAddCommGroup α] → NormedAddCommGroup (Matrix m n α) | true |
Finset.Ico_subset_Ici_self | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] [inst_2 : LocallyFiniteOrder α],
Finset.Ico a b ⊆ Finset.Ici a | true |
_private.Mathlib.NumberTheory.ModularForms.Delta.0.ModularForm.eta_comp_eqOn_const_mul_csqrt_eta | Mathlib.NumberTheory.ModularForms.Delta | ∃ c,
c ≠ 0 ∧
Set.EqOn (ModularForm.eta ∘ fun z => -1 / z) (c • (Complex.sqrt * ModularForm.eta)) UpperHalfPlane.upperHalfPlaneSet | true |
FiniteMulArchimedeanClass.closedBallSubgroup | Mathlib.Algebra.Order.Archimedean.Class | {M : Type u_1} →
[inst : CommGroup M] →
[inst_1 : LinearOrder M] → [inst_2 : IsOrderedMonoid M] → FiniteMulArchimedeanClass M → Subgroup M | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.ErrorContext.mk.sizeOf_spec | Mathlib.Tactic.Linter.TextBased | ∀ (error : Mathlib.Linter.TextBased.StyleError✝) (lineNumber : ℕ) (path : System.FilePath),
sizeOf { error := error, lineNumber := lineNumber, path := path } = 1 + sizeOf error + sizeOf lineNumber + sizeOf path | true |
_private.Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra.0.Module.FaithfullyFlat.faithfulSMul._simp_1 | Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra | ∀ {α : Type u_9} [inst : Mul α] (a b : α), a * b = a • b | false |
Std.BundledIterM.casesOn | Std.Data.Iterators.Lemmas.Equivalence.Basic | {m : Type w → Type w'} →
{β : Type w} →
{motive : Std.BundledIterM m β → Sort u} →
(t : Std.BundledIterM m β) →
((α : Type w) →
(inst : Std.Iterator α m β) →
(iterator : Std.IterM m β) → motive { α := α, inst := inst, iterator := iterator }) →
motive t | false |
CategoryTheory.EnrichedOrdinaryCategory.casesOn | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | {V : Type u'} →
[inst : CategoryTheory.Category.{v', u'} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u} →
[inst_2 : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.EnrichedOrdinaryCategory V C → Sort u_1} →
(t : CategoryTheory.EnrichedOrdinaryCate... | false |
Ideal.ramificationIdx_eq_one_of_isUnramifiedAt | Mathlib.NumberTheory.RamificationInertia.Unramified | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {p : Ideal S}
[inst_3 : p.IsPrime] [IsNoetherianRing S] [Algebra.IsUnramifiedAt R p],
p ≠ ⊥ → ∀ [IsDomain S] [Algebra.EssFiniteType R S], (Ideal.under R p).ramificationIdx p = 1 | true |
IsCompactOperator.restrict | Mathlib.Analysis.Normed.Operator.Compact | ∀ {R₁ : Type u_1} [inst : Semiring R₁] {M₁ : Type u_3} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R₁ M₁] {f : M₁ →ₗ[R₁] M₁},
IsCompactOperator ⇑f →
∀ {V : Submodule R₁ M₁} (hV : ∀ v ∈ V, f v ∈ V), IsClosed ↑V → IsCompactOperator ⇑(f.restrict hV) | true |
_private.Mathlib.NumberTheory.SiegelsLemma.0.Int.Matrix._aux_Mathlib_NumberTheory_SiegelsLemma___macroRules__private_Mathlib_NumberTheory_SiegelsLemma_0_Int_Matrix_termB_1 | Mathlib.NumberTheory.SiegelsLemma | Lean.Macro | false |
Rat.num_divInt_den | Init.Data.Rat.Lemmas | ∀ (a : ℚ), Rat.divInt a.num ↑a.den = a | true |
PosNum.cast_one | Mathlib.Data.Num.Lemmas | ∀ {α : Type u_1} [inst : One α] [inst_1 : Add α], ↑1 = 1 | true |
hnot_top | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α], ￢⊤ = ⊥ | true |
CategoryTheory.MorphismProperty.IsMonoidalStable.mk._flat_ctor | Mathlib.CategoryTheory.Monoidal.Widesubcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.MorphismProperty C}
[inst_1 : CategoryTheory.MonoidalCategory C],
(∀ (X : C), P (CategoryTheory.CategoryStruct.id X)) →
(∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z), P f → P g → P (CategoryTheory.CategoryStruct.comp f g)) →
(∀ (X... | false |
CommSemiRingCat.forget_preservesLimits | Mathlib.Algebra.Category.Ring.Limits | CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget CommSemiRingCat) | true |
finprod_mem_eq_prod | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] (f : α → M) {s : Set α} (hf : (s ∩ Function.mulSupport f).Finite),
∏ᶠ (i : α) (_ : i ∈ s), f i = ∏ i ∈ hf.toFinset, f i | true |
Nat.eq_zero_of_lcm_eq_zero | Init.Data.Nat.Lcm | ∀ {m n : ℕ}, m.lcm n = 0 → m = 0 ∨ n = 0 | true |
Module.Basis.coe_toOrthonormalBasis | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] (v : Module.Basis ι 𝕜 E) (hv : Orthonormal 𝕜 ⇑v),
⇑(v.toOrthonormalBasis hv) = ⇑v | true |
CategoryTheory.Functor.leftExtensionEquivalenceOfIso₁_unitIso_hom_app_right_app | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_4, u_4} D]
{L L' : CategoryTheory.Functor C D} (iso₁ : L ≅ L') (F : CategoryTheory.Functor C H)
(X : CategoryTheory.Comma (CategoryTheor... | true |
Height.fun_logHeight_one | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] {ι : Type u_2},
(Height.logHeight fun x => 1) = 0 | true |
_private.Mathlib.Geometry.Manifold.IntegralCurve.UniformTime.0.exists_isMIntegralCurve_of_isMIntegralCurveOn._simp_1_1 | Mathlib.Geometry.Manifold.IntegralCurve.UniformTime | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ioo a b) = (a < x ∧ x < b) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.