name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.go._unary._proof_2 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ) (ht₀ : 0 < table.size),
(∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) → table[table.size - 1] < table.size | false |
RingCone.eq_zero_of_mem_of_neg_mem' | Mathlib.Algebra.Order.Ring.Cone | ∀ {R : Type u_1} [inst : Ring R] (self : RingCone R) {a : R}, a ∈ self.carrier → -a ∈ self.carrier → a = 0 | true |
instLEISize | Init.Data.SInt.Basic | LE ISize | true |
SeparationQuotient.instCommGroup.eq_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : CommGroup G] [inst_2 : IsTopologicalGroup G],
SeparationQuotient.instCommGroup = { toGroup := SeparationQuotient.instGroup, mul_comm := ⋯ } | true |
AlgebraicGeometry.Scheme.instIsStableUnderCompositionFpqcPrecoverage._proof_1 | Mathlib.AlgebraicGeometry.Sites.Fpqc | AlgebraicGeometry.Scheme.fpqcPrecoverage.IsStableUnderComposition | false |
LinearOrderedRing.orderOf_le_two | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Ring G] [inst_1 : LinearOrder G] [IsStrictOrderedRing G] {x : G}, orderOf x ≤ 2 | true |
_private.Mathlib.Topology.Instances.ENat.0.ENat.instContinuousAdd.match_1 | Mathlib.Topology.Instances.ENat | ∀ (motive : ℕ∞ × ℕ∞ → Prop) (x : ℕ∞ × ℕ∞), (∀ (a b : ℕ∞), motive (a, b)) → motive x | false |
ProbabilityTheory.HasGaussianLaw.map_equiv | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {F : Type u_3} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω}
[inst : NormedAddCommGroup E] [inst_1 : MeasurableSpace E] [BorelSpace E] {X : Ω → E} [inst_3 : NormedSpace ℝ E]
[inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace ℝ F] [inst_6 : MeasurableSpace F] [BorelSpace F... | true |
_private.Mathlib.Probability.Moments.IntegrableExpMul.0.ProbabilityTheory.rpow_abs_le_mul_max_exp_of_pos._simp_1_1 | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a ≤ max b c) = (a ≤ b ∨ a ≤ c) | false |
_private.Mathlib.MeasureTheory.Covering.Differentiation.0.VitaliFamily.ae_tendsto_div._simp_1_4 | Mathlib.MeasureTheory.Covering.Differentiation | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | false |
Lean.Parser.Term.doAssert.parenthesizer | Lean.Parser.Do | Lean.PrettyPrinter.Parenthesizer | true |
_private.Mathlib.Tactic.FailIfNoProgress.0.Mathlib.Tactic.lctxIsDefEq.match_1.splitter | Mathlib.Tactic.FailIfNoProgress | (motive : List (Option Lean.LocalDecl) → List (Option Lean.LocalDecl) → Sort u_1) →
(x x_1 : List (Option Lean.LocalDecl)) →
((l₁ l₂ : List (Option Lean.LocalDecl)) → motive (none :: l₁) l₂) →
((l₁ l₂ : List (Option Lean.LocalDecl)) →
(∀ (l₁_1 : List (Option Lean.LocalDecl)), l₁ = none :: l₁_1 → F... | true |
CategoryTheory.Presheaf.secondMap.eq_1 | Mathlib.CategoryTheory.Sites.Sheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} A]
{U : C} (R : CategoryTheory.Presieve U) (P : CategoryTheory.Functor Cᵒᵖ A)
[inst_2 : CategoryTheory.Limits.HasProducts A] [inst_3 : CategoryTheory.Limits.HasPullbacks C],
CategoryTheory.Presheaf... | true |
NumberField.mixedEmbedding.homeoRealMixedSpacePolarSpace_apply | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord | ∀ (K : Type u_1) [inst : Field K] (x : NumberField.mixedEmbedding.realMixedSpace K),
(NumberField.mixedEmbedding.homeoRealMixedSpacePolarSpace K) x =
(fun w => if hw : w.IsReal then x.1 ⟨w, hw⟩ else (x.2 ⟨w, ⋯⟩).1, fun w => (x.2 w).2) | true |
String.Slice.Pos.posGT_offset | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {p : s.Pos} {h : p.offset < s.rawEndPos}, s.posGT p.offset h = p.next ⋯ | true |
Mathlib.Tactic.Translate.TranslateData.ctorIdx | Mathlib.Tactic.Translate.Core | Mathlib.Tactic.Translate.TranslateData → ℕ | false |
CategoryTheory.CreatesColimitsOfSize.mk | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
autoParam
({J : Type w} → [inst_2 : CategoryTheory.Category.{w', w} J] → CategoryTheory.CreatesColimitsOfShape J F)... | true |
FractionalIdeal.coe_one_eq_coeSubmodule_top | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P],
↑1 = IsLocalization.coeSubmodule P ⊤ | true |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.le_ofSliceTo_iff.match_1_1 | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ : s.Pos} {p : (s.sliceTo p₀).Pos} {q : s.Pos} (motive : (∃ (h : q ≤ p₀), p₀.sliceTo q h ≤ p) → Prop)
(x : ∃ (h : q ≤ p₀), p₀.sliceTo q h ≤ p), (∀ (h : q ≤ p₀) (h' : p₀.sliceTo q h ≤ p), motive ⋯) → motive x | false |
CategoryTheory.ShortComplex.rightHomologyMapIso'._proof_2 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) (h₁ : S₁.RightHomologyData) (h₂ : S₂.RightHomologyData),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.rightHomologyMap' e.inv h₂... | false |
BitVec.getMsbD_sdiv | Init.Data.BitVec.Bitblast | ∀ {w i : ℕ} {x y : BitVec w},
(x.sdiv y).getMsbD i =
match x.msb, y.msb with
| false, false => (x / y).getMsbD i
| false, true => (-(x / -y)).getMsbD i
| true, false => (-(-x / y)).getMsbD i
| true, true => (-x / -y).getMsbD i | true |
AlgebraicGeometry.tilde.instModuleCarrierCarrierStalkAbPresheaf._proof_3 | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} (M : ModuleCat ↑R) (x : ↑(AlgebraicGeometry.PrimeSpectrum.Top ↑R)) (x_1 y : ↑R)
(b : ↑((AlgebraicGeometry.tilde M).presheaf.stalk x)), (x_1 * y) • b = x_1 • y • b | false |
Lean.IR.Alt.brecOn.go | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.Alt → Sort u} →
{motive_2 : Lean.IR.FnBody → Sort u} →
{motive_3 : Array Lean.IR.Alt → Sort u} →
{motive_4 : List Lean.IR.Alt → Sort u} →
(t : Lean.IR.Alt) →
((t : Lean.IR.Alt) → t.below → motive_1 t) →
((t : Lean.IR.FnBody) → t.below → motive_2 t) →
... | true |
_private.Lean.Compiler.LCNF.Specialize.0.Lean.Compiler.LCNF.Specialize.Context.casesOn | Lean.Compiler.LCNF.Specialize | {motive : Lean.Compiler.LCNF.Specialize.Context✝ → Sort u} →
(t : Lean.Compiler.LCNF.Specialize.Context✝) →
((scope ground underApplied : Lean.FVarIdSet) →
(declName : Lean.Name) →
motive { scope := scope, ground := ground, underApplied := underApplied, declName := declName }) →
motive t | false |
Valuation.integer._proof_3 | Mathlib.RingTheory.Valuation.Integers | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀),
0 ∈ {x | v x ≤ 1} | false |
_private.Mathlib.Geometry.Manifold.IsManifold.Basic.0.IsManifold.disjointUnion.match_3 | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {H : Type u_1} [inst : TopologicalSpace H] {M : Type u_2} [inst_1 : TopologicalSpace M] {M' : Type u_3}
[inst_2 : TopologicalSpace M'] (h : Nonempty H) (f : OpenPartialHomeomorph M' H) (f' : OpenPartialHomeomorph M H)
(x : H) (motive : x ∈ ((f.lift_openEmbedding ⋯).symm.trans (f'.lift_openEmbedding ⋯)).source → P... | false |
Lean.Meta.instReduceEvalLevelMVarId | Lean.Meta.ReduceEval | Lean.Meta.ReduceEval Lean.LevelMVarId | true |
Order.not_isSuccLimit | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α], ¬Order.IsSuccLimit a | true |
ContDiffMapSupportedIn.instZero._proof_1 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞}, ContDiff ℝ ↑n fun x => 0 | false |
CategoryTheory.GrothendieckTopology.uliftYonedaOpCompCoyoneda | Mathlib.CategoryTheory.Sites.Subcanonical | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
[inst_1 : J.Subcanonical] →
(CategoryTheory.GrothendieckTopology.uliftYoneda.{v', v, u} J).op.comp CategoryTheory.coyoneda ≅
(CategoryTheory.evaluation Cᵒᵖ (Type (max v v'))).comp
... | true |
CategoryTheory.Types.instIsStableUnderCoproductsOfShapeMonomorphismsType | Mathlib.CategoryTheory.Types.Monomorphisms | ∀ (T : Type u'), (CategoryTheory.MorphismProperty.monomorphisms (Type u)).IsStableUnderCoproductsOfShape T | true |
CategoryTheory.IsCofiltered.cofilteredClosure.below.eq | Mathlib.CategoryTheory.Filtered.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.IsCofilteredOrEmpty C] {α : Type w}
{f : α → C} {motive : (a : C) → CategoryTheory.IsCofiltered.cofilteredClosure f a → Prop} {j j' : C}
(a : CategoryTheory.IsCofiltered.cofilteredClosure f j) (a_1 : CategoryTheory.IsCofiltered.cofilt... | true |
Std.Tactic.BVDecide.BVExpr.bitblast.mkFullAdderOut | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
(aig : Std.Sat.AIG α) → Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderInput aig → Std.Sat.AIG.Entrypoint α | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.SynthInstance.mkTableKey.match_1 | Lean.Meta.SynthInstance | (motive : Id (Lean.Expr × Lean.Meta.SynthInstance.MkTableKey.State) → Sort u_1) →
(x : Id (Lean.Expr × Lean.Meta.SynthInstance.MkTableKey.State)) →
((r : Lean.Expr) → (s : Lean.Meta.SynthInstance.MkTableKey.State) → motive (r, s)) → motive x | false |
FreeAddGroup.ext_hom | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {M : Type u_1} [inst : AddMonoid M] (f g : FreeAddGroup α →+ M),
(∀ (a : α), f (FreeAddGroup.of a) = g (FreeAddGroup.of a)) → f = g | true |
ContinuousLinearMap.closure_preimage | Mathlib.Analysis.Normed.Operator.Banach | ∀ {𝕜 : Type u_1} {𝕜' : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜'] {σ : 𝕜 →+* 𝕜'}
{E : Type u_3} [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {F : Type u_4}
[inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace 𝕜' F] (f : E →SL[σ] F) {σ' : 𝕜' →+* 𝕜} [Ri... | true |
IsLocalization.invertible_mk'_one._proof_2 | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_2} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_1} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (s : ↥M), (algebraMap R S) ↑s * IsLocalization.mk' S 1 s = 1 | false |
CategoryTheory.ShiftedHom.mk₀_comp_mk₀_assoc | Mathlib.CategoryTheory.Shift.ShiftedHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {M : Type u_4} [inst_1 : AddMonoid M]
[inst_2 : CategoryTheory.HasShift C M] {X Y Z T : C} (f : X ⟶ Y) (g : Y ⟶ Z) {a : M} (ha : a = 0) {d : M}
(h : CategoryTheory.ShiftedHom Z T d),
(CategoryTheory.ShiftedHom.mk₀ a ha f).comp ((CategoryTheory.Shifted... | true |
groupCohomology.cochainsMap_f_3_comp_cochainsIso₃_assoc | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k H}
{B : Rep.{u, u, u} k G} (f : G →* H) (φ : Rep.res f A ⟶ B) {Z : ModuleCat k}
(h : ModuleCat.of k (G × G × G → ↑B) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((groupCohomology.cochainsMap f φ).f 3)
(CategoryThe... | true |
CategoryTheory.IsPushout.rec | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{Z X Y P : C} →
{f : Z ⟶ X} →
{g : Z ⟶ Y} →
{inl : X ⟶ P} →
{inr : Y ⟶ P} →
{motive : CategoryTheory.IsPushout f g inl inr → Sort u} →
((toCommSq : CategoryTheory.CommSq f g inl inr) →
... | false |
MeasureTheory.HasFiniteIntegral.of_subsingleton_codomain | Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {ε : Type u_7} [inst : TopologicalSpace ε]
[inst_1 : ESeminormedAddMonoid ε] [Subsingleton ε] {f : α → ε}, MeasureTheory.HasFiniteIntegral f μ | true |
Array.getElem_succ_scanl._proof_2 | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {i : ℕ} {b : β} {as : Array α} {f : β → α → β},
i + 1 < (Array.scanl f b as).size → i < (Array.scanl f b as).size | false |
Set.Subsingleton.strictAntiOn | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u} {β : Type v} {s : Set α} [inst : Preorder α] [inst_1 : Preorder β] (f : α → β),
s.Subsingleton → StrictAntiOn f s | true |
WithZeroTopology.t5Space | Mathlib.Topology.Algebra.WithZeroTopology | ∀ {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀], T5Space Γ₀ | true |
Std.ExtDTreeMap.mem_diff_iff | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α}, k ∈ t₁ \ t₂ ↔ k ∈ t₁ ∧ k ∉ t₂ | true |
Subspace.dualAnnihilatorGci._proof_2 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ (K : Type u_2) (V : Type u_1) [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V],
GaloisConnection (⇑OrderDual.toDual ∘ Submodule.dualAnnihilator) (Submodule.dualCoannihilator ∘ ⇑OrderDual.ofDual) | false |
Std.TreeSet.isEmpty_iff_forall_not_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp], t.isEmpty = true ↔ ∀ (a : α), a ∉ t | true |
Topology.RelCWComplex.mapsTo | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u} {inst : TopologicalSpace X} {C : Set X} {D : outParam (Set X)} [self : Topology.RelCWComplex C D] (n : ℕ)
(i : Topology.RelCWComplex.cell C n),
∃ I,
Set.MapsTo (↑(Topology.RelCWComplex.map n i)) (Metric.sphere 0 1)
(D ∪ ⋃ m, ⋃ (_ : m < n), ⋃ j ∈ I m, ↑(Topology.RelCWComplex.map m j) '' Metr... | true |
AdicCompletion.instSMulQuotientIdealHSMulTopSubmodule._proof_2 | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M], IsScalarTower R R M | false |
Module.Presentation.ofExact_relation | Mathlib.Algebra.Module.Presentation.Cokernel | ∀ {A : Type u} [inst : Ring A] {M₁ : Type v₁} {M₂ : Type v₂} {M₃ : Type v₃} [inst_1 : AddCommGroup M₁]
[inst_2 : Module A M₁] [inst_3 : AddCommGroup M₂] [inst_4 : Module A M₂] [inst_5 : AddCommGroup M₃]
[inst_6 : Module A M₃] {f : M₁ →ₗ[A] M₂} {g : M₂ →ₗ[A] M₃} (pres₂ : Module.Presentation A M₂) {ι : Type w₁}
{g₁... | true |
_private.Mathlib.Combinatorics.Schnirelmann.0.add_eq_univ_of_one_le_schirelmannDensity_add_schnirelmannDensity._simp_1_9 | Mathlib.Combinatorics.Schnirelmann | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ioc a b) = (a < x ∧ x ≤ b) | false |
CategoryTheory.ProjectiveResolution.liftHomotopyZeroOne._proof_2 | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {Z : C}
{Q : CategoryTheory.ProjectiveResolution Z},
CategoryTheory.CategoryStruct.comp (Q.complex.d (0 + 2) (0 + 1)) (Q.complex.d (0 + 1) 0) = 0 | false |
Lean.instToMessageDataString | Lean.Message | Lean.ToMessageData String | true |
ContinuousLinearMap.hasFiniteFPowerSeriesOnBall_uncurry_of_multilinear | Mathlib.Analysis.Analytic.CPolynomial | ∀ {𝕜 : Type u_1} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] [inst_3 : NormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] {ι : Type u_5}
{Em : ι → Type u_6} [inst_5 : (i : ι) → NormedAddCommGroup (Em i)] [inst_6 : (i : ι) → NormedSpac... | true |
IsLocalization.localization_localization_isLocalization_of_has_all_units | Mathlib.RingTheory.Localization.LocalizationLocalization | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] (N : Submonoid S) (T : Type u_3) [inst_3 : CommSemiring T] [inst_4 : Algebra R T]
[inst_5 : Algebra S T] [IsScalarTower R S T] [IsLocalization M S] [IsLocalization N T],
(∀ (x : S), IsUnit x ... | true |
Stream'.Seq.drop_nil | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {n : ℕ}, Stream'.Seq.nil.drop n = Stream'.Seq.nil | true |
CategoryTheory.Abelian.SpectralObject.isoMapFourδ₁Toδ₀'_hom_inv_id | Mathlib.Algebra.Homology.SpectralObject.EpiMono | ∀ {C : Type u_1} {ι' : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : Preorder ι'] (X' : CategoryTheory.Abelian.SpectralObject C ι') (i₀ i₁ i₂ i₃ i₄ : ι') (hi₀₁ : i₀ ≤ i₁)
(hi₁₂ : i₁ ≤ i₂) (hi₂₃ : i₂ ≤ i₃) (hi₃₄ : i₃ ≤ i₄) (n₀ n₁ n₂ : ℤ)
(h : CategoryTheory.L... | true |
CategoryTheory.ComposableArrows.whiskerLeftFunctor._proof_2 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {n m : ℕ}
(Φ : CategoryTheory.Functor (Fin (n + 1)) (Fin (m + 1))) {X Y Z : CategoryTheory.ComposableArrows C m} (f : X ⟶ Y)
(g : Y ⟶ Z),
Φ.whiskerLeft (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (Φ.whiskerLeft f)... | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.mem_of_insertRatUnits._simp_1_3 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {α : Type u_1} {a : α} {s t : List α}, (a ∈ s ++ t) = (a ∈ s ∨ a ∈ t) | false |
MeasureTheory.integral_iUnion_ae | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{f : X → E} {μ : MeasureTheory.Measure X} {ι : Type u_5} [Countable ι] {s : ι → Set X},
(∀ (i : ι), MeasureTheory.NullMeasurableSet (s i) μ) →
Pairwise (Function.onFun (MeasureTheory.AEDisjoint μ) s... | true |
Real.posLog_le_posLog | Mathlib.Analysis.SpecialFunctions.Log.PosLog | ∀ {x y : ℝ}, 0 ≤ x → x ≤ y → x.posLog ≤ y.posLog | true |
Lean.Compiler.LCNF.InferType.Pure.inferConstType | Lean.Compiler.LCNF.InferType | Lean.Name → List Lean.Level → Lean.Compiler.LCNF.CompilerM Lean.Expr | true |
_private.Init.Data.List.Lemmas.0.List.forall_mem_singleton._simp_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {a b : α}, (a ∈ [b]) = (a = b) | false |
String.rawEndPos_toSlice | Init.Data.String.Basic | ∀ {s : String}, s.toSlice.rawEndPos = s.rawEndPos | true |
CancelCommMonoidWithZero.noConfusion | Mathlib.Algebra.GroupWithZero.Defs | {P : Sort u} →
{M₀ : Type u_2} →
{t : CancelCommMonoidWithZero M₀} →
{M₀' : Type u_2} →
{t' : CancelCommMonoidWithZero M₀'} → M₀ = M₀' → t ≍ t' → CancelCommMonoidWithZero.noConfusionType P t t' | false |
_private.Lean.Compiler.LCNF.LambdaLifting.0.Lean.Compiler.LCNF.LambdaLifting.etaContractibleDecl?.match_6 | Lean.Compiler.LCNF.LambdaLifting | (motive : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(x : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) →
((letVar : Lean.FVarId) →
(binderName : Lean.Name) →
(type : Lean.Expr) →
(declName : Lean.Name) →
(us : List Lean.Level) →
... | false |
CategoryTheory.FreeBicategory.Rel.below.whisker_left | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B]
{motive :
{a b : CategoryTheory.FreeBicategory B} →
{f g : a ⟶ b} →
(a_1 a_2 : CategoryTheory.FreeBicategory.Hom₂ f g) → CategoryTheory.FreeBicategory.Rel a_1 a_2 → Prop}
{a b c : B} (f : CategoryTheory.FreeBicategory.Hom a b) (g h : CategoryTheory.FreeBicategory.H... | true |
Std.Internal.IO.Async.BaseAsync | Std.Internal.Async.Basic | Type → Type | true |
_private.Mathlib.Analysis.SpecificLimits.Normed.0.alternating_series_error_bound._simp_1_1 | Mathlib.Analysis.SpecificLimits.Normed | ∀ {α : Type u_2} [inst : AddMonoidWithOne α], Even 2 = True | false |
Order.IsSuccPrelimit.succ_ne | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α] [inst_1 : SuccOrder α] [NoMaxOrder α],
Order.IsSuccPrelimit a → ∀ (b : α), Order.succ b ≠ a | true |
IsDedekindDomain.HeightOneSpectrum.mk | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | {R : Type u_1} →
[inst : CommRing R] → (asIdeal : Ideal R) → asIdeal.IsPrime → asIdeal ≠ ⊥ → IsDedekindDomain.HeightOneSpectrum R | true |
CategoryTheory.shiftFunctorCompIsoId.eq_1 | Mathlib.CategoryTheory.Shift.Basic | ∀ (C : Type u) {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (i j : A) (h : i + j = 0),
CategoryTheory.shiftFunctorCompIsoId C i j h =
(CategoryTheory.shiftFunctorAdd' C i j 0 h).symm ≪≫ CategoryTheory.shiftFunctorZero C A | true |
Std.Do.Option.instWPMonad | Std.Do.WP.Monad | Std.Do.WPMonad Option (Std.Do.PostShape.except PUnit.{u_1 + 1} Std.Do.PostShape.pure) | true |
Real.one_sub_inv_le_log_of_pos | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ {x : ℝ}, 0 < x → 1 - x⁻¹ ≤ Real.log x | true |
Lean.Lsp.instToJsonPlainGoalParams.toJson | Lean.Data.Lsp.Extra | Lean.Lsp.PlainGoalParams → Lean.Json | true |
CategoryTheory.Functor.mapExtAddHom_apply | Mathlib.Algebra.Homology.DerivedCategory.Ext.Map | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] [inst_3 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D)
[inst_4 : F.Additive] [inst_5 : CategoryTheory.Limits.PreservesFiniteLimits F]
[inst_6 : Cat... | true |
CochainComplex.mappingCone.mapHomologicalComplexIso.eq_1 | Mathlib.Algebra.Homology.HomotopyCategory.ShortExact | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v, u_1} C]
[inst_1 : CategoryTheory.Category.{v', u_2} D] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.Preadditive D] {F G : CochainComplex C ℤ} (φ : F ⟶ G)
[inst_4 : HomologicalComplex.HasHomotopyCofiber φ] (H : CategoryTheory.F... | true |
Metric.infDist.eq_1 | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoMetricSpace α] (x : α) (s : Set α), Metric.infDist x s = (Metric.infEDist x s).toReal | true |
CategoryTheory.TwoSquare.whiskerVertical_app | Mathlib.CategoryTheory.GuitartExact.VerticalComposition | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D₁ : Type u_4} {D₂ : Type u_5} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_4, u_4} D₁]
[inst_3 : CategoryTheory.Category.{v_5, u_5} D₂] {T : CategoryTheory.Functor C₁ D₁} {L : CategoryTheory.F... | true |
CategoryTheory.Sum.inl__obj | Mathlib.CategoryTheory.Sums.Basic | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(X : C), (CategoryTheory.Sum.inl_ C D).obj X = Sum.inl X | true |
UpperSet.sdiff_eq_left | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : UpperSet α} {t : Set α}, s.sdiff t = s ↔ Disjoint (↑s) t | true |
ScottContinuous.monotone | Mathlib.Order.ScottContinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β}, ScottContinuous f → Monotone f | true |
ContinuousMapZero.instNormedAddCommGroup._proof_2 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {α : Type u_1} {R : Type u_2} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : Zero α]
[inst_3 : NormedAddCommGroup R] (f g : ContinuousMapZero α R), dist ↑f ↑g = ‖-↑f + ↑g‖ | false |
InnerProductSpace.euclideanHausdorffMeasure_eq_volume | Mathlib.Geometry.Euclidean.Volume.Measure | ∀ {V : Type u_3} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MeasurableSpace V]
[inst_3 : BorelSpace V] [inst_4 : FiniteDimensional ℝ V],
MeasureTheory.Measure.euclideanHausdorffMeasure (Module.finrank ℝ V) = MeasureTheory.volume | true |
CategoryTheory.MorphismProperty.Over.mapComp_hom_app_left | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P : CategoryTheory.MorphismProperty T}
(Q : CategoryTheory.MorphismProperty T) [inst_1 : Q.IsMultiplicative] {X Y Z : T}
[inst_2 : P.IsStableUnderComposition] {f : X ⟶ Y} (hf : P f) {g : Y ⟶ Z} (hg : P g) [inst_3 : Q.RespectsIso]
(fg : optParam (X ⟶ ... | true |
_private.Lean.Meta.Tactic.Grind.Core.0.Lean.Meta.Grind.invertTrans.go | Lean.Meta.Tactic.Grind.Core | Lean.Expr → Bool → Option Lean.Expr → Option Lean.Expr → Lean.Meta.Grind.GoalM Unit | true |
OrderedFinpartition.extendLeft | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | {n : ℕ} → OrderedFinpartition n → OrderedFinpartition (n + 1) | true |
Int.neg_le_neg_iff | Init.Data.Int.Order | ∀ {a b : ℤ}, -a ≤ -b ↔ b ≤ a | true |
MvQPF.Cofix.mk | Mathlib.Data.QPF.Multivariate.Constructions.Cofix | {n : ℕ} →
{F : TypeVec.{u} (n + 1) → Type u} → [q : MvQPF F] → {α : TypeVec.{u} n} → F (α ::: MvQPF.Cofix F α) → MvQPF.Cofix F α | true |
skewAdjointMatricesSubmodule | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | {R : Type u_1} →
{n : Type u_11} → [inst : CommRing R] → [Fintype n] → Matrix n n R → [DecidableEq n] → Submodule R (Matrix n n R) | true |
AddMonoidHom.toMultiplicativeLeft._proof_6 | Mathlib.Algebra.Group.TypeTags.Hom | ∀ {α : Type u_1} {β : Type u_2} [inst : AddZeroClass α] [inst_1 : MulOneClass β] (f : Multiplicative α →* β)
(a b : Multiplicative α), f (a * b) = f a * f b | false |
PartialEquiv.trans | Mathlib.Logic.Equiv.PartialEquiv | {α : Type u_1} → {β : Type u_2} → {γ : Type u_3} → PartialEquiv α β → PartialEquiv β γ → PartialEquiv α γ | true |
_private.Mathlib.NumberTheory.ArithmeticFunction.LFunction.0.ArithmeticFunction.ofPowerSeries._simp_7 | Mathlib.NumberTheory.ArithmeticFunction.LFunction | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | false |
RingHom.ker.eq_1 | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
[rcf : RingHomClass F R S] (f : F), RingHom.ker f = Ideal.comap f ⊥ | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.collectDirectVarsInPattern | Lean.Meta.IndPredBelow | Lean.Meta.Match.Pattern → Array Lean.FVarId | true |
LieAlgebra.ExtendScalars.instBracketTensorProduct._proof_2 | Mathlib.Algebra.Lie.BaseChange | ∀ (R : Type u_3) (A : Type u_1) (M : Type u_2) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : AddCommGroup M] [inst_4 : Module R M], SMulCommClass A A (TensorProduct R A M) | false |
CategoryTheory.Limits.hasColimitsOfSize_skeleton | Mathlib.CategoryTheory.Limits.Skeleton | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] [CategoryTheory.Limits.HasColimitsOfSize.{w, w', v₂, u₂} C],
CategoryTheory.Limits.HasColimitsOfSize.{w, w', v₂, u₂} (CategoryTheory.Skeleton C) | true |
EuclideanGeometry.«term∡» | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | Lean.ParserDescr | true |
StrongDual.toLpₗ_of_not_memLp | Mathlib.Probability.Moments.CovarianceBilinDual | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {mE : MeasurableSpace E} {μ : MeasureTheory.Measure E} {p : ENNReal}
{𝕜 : Type u_2} [inst_1 : NontriviallyNormedField 𝕜] [inst_2 : NormedSpace 𝕜 E],
¬MeasureTheory.MemLp id p μ → ∀ (L : StrongDual 𝕜 E), (StrongDual.toLpₗ μ p) L = 0 | true |
Mathlib.Tactic.Linarith.CompSource.add.inj | Mathlib.Tactic.Linarith.Oracle.FourierMotzkin | ∀ {a a_1 a_2 a_3 : Mathlib.Tactic.Linarith.CompSource}, a.add a_1 = a_2.add a_3 → a = a_2 ∧ a_1 = a_3 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.