name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Algebra.Polynomial.Monic.0.Polynomial.Monic.natDegree_mul'._simp_1_1 | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, (p.leadingCoeff ≠ 0) = (p ≠ 0) | false |
LieModule.toEnd | Mathlib.Algebra.Lie.OfAssociative | (R : Type u) →
(L : Type v) →
(M : Type w) →
[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] → [LieModule R L M] → L →ₗ⁅R⁆ Module.End R M | true |
CategoryTheory.ChosenPullbacksAlong.Over.tensorHom_left_fst | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.ChosenPullbacks C] {X : C}
{R S T U : CategoryTheory.Over X} (f : R ⟶ S) (g : T ⟶ U),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom f g).left
(CategoryTheory.ChosenPullbacksAlong.fst S.hom U.hom) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.ChosenPullbacksAlong.fst R.hom T.hom) f.left | true |
Nat.ModEq.listSum_zero | Mathlib.Algebra.BigOperators.ModEq | ∀ {n : ℕ} {l : List ℕ}, (∀ x ∈ l, x ≡ 0 [MOD n]) → l.sum ≡ 0 [MOD n] | true |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.isLocalization_away_iff_atPrime_of_basicOpen_eq_singleton.match_1_2 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u_1} [inst : CommSemiring R] {f : R} (r : R)
(motive : (∃ p, p.IsPrime ∧ Ideal.span {r} ≤ p ∧ Disjoint ↑p ↑(Submonoid.powers f)) → Prop)
(x : ∃ p, p.IsPrime ∧ Ideal.span {r} ≤ p ∧ Disjoint ↑p ↑(Submonoid.powers f)),
(∀ (q : Ideal R) (prime : q.IsPrime) (le : Ideal.span {r} ≤ q) (disj : Disjoint ↑q ↑(Submonoid.powers f)), motive ⋯) →
motive x | false |
Std.DTreeMap.Internal.Cell.getEntry?.match_1 | Std.Data.DTreeMap.Internal.Cell | {α : Type u_2} →
{β : α → Type u_1} →
(motive : Option ((a : α) × β a) → Sort u_3) →
(x : Option ((a : α) × β a)) → (Unit → motive none) → ((p : (a : α) × β a) → motive (some p)) → motive x | false |
CategoryTheory.Join.instCategory._proof_15 | Mathlib.CategoryTheory.Join.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {x y : CategoryTheory.Join C D} (f : x.Hom y),
CategoryTheory.Join.comp f y.id = f | false |
Lean.Meta.Grind.CanonArgKey.i | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.CanonArgKey → ℕ | true |
InnerProductSpace.ringOfCoalgebra._proof_21 | Mathlib.Analysis.InnerProductSpace.Coalgebra | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] (a : E), -a + a = 0 | false |
NFA.evalFrom.eq_1 | Mathlib.Computability.NFA | ∀ {α : Type u} {σ : Type v} (M : NFA α σ) (S : Set σ), M.evalFrom S = List.foldl M.stepSet S | true |
gcd_zero_right | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a : α), gcd a 0 = normalize a | true |
CategoryTheory.LaxBraidedFunctor.instCategory._proof_8 | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u_4} [inst_3 : CategoryTheory.Category.{u_2, u_4} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D],
autoParam
(∀ {X Y : CategoryTheory.LaxBraidedFunctor C D} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f)
CategoryTheory.Category.comp_id._autoParam | false |
Lean.Doc.instOrdMathMode.ord | Lean.DocString.Types | Lean.Doc.MathMode → Lean.Doc.MathMode → Ordering | true |
HasSummableGeomSeries.mk | Mathlib.Analysis.SpecificLimits.Normed | ∀ {K : Type u_4} [inst : NormedRing K], (∀ (ξ : K), ‖ξ‖ < 1 → Summable fun n => ξ ^ n) → HasSummableGeomSeries K | true |
ShrinkingLemma.PartialRefinement.chainSup._proof_1 | Mathlib.Topology.ShrinkingLemma | ∀ {ι : Type u_2} {X : Type u_1} [inst : TopologicalSpace X] {u : ι → Set X} {s : Set X} {p : Set X → Prop}
(c : Set (ShrinkingLemma.PartialRefinement u s p)) (ne : c.Nonempty) (i : ι),
IsOpen ((ShrinkingLemma.PartialRefinement.find c ne i).toFun i) | false |
_private.Mathlib.CategoryTheory.GradedObject.Monoidal.0.CategoryTheory.GradedObject.instFiniteElemProdNatPreimageHAddFstSndSingletonSet._proof_3 | Mathlib.CategoryTheory.GradedObject.Monoidal | ∀ (n i₁ i₂ : ℕ), i₁ + i₂ = n → i₁ < n + 1 | false |
Matrix.linftyOpNormSMulClass | Mathlib.Analysis.Matrix.Normed | ∀ {R : Type u_1} {m : Type u_3} {n : Type u_4} {α : Type u_5} [inst : Fintype m] [inst_1 : Fintype n]
[inst_2 : SeminormedRing R] [inst_3 : SeminormedAddCommGroup α] [inst_4 : Module R α] [NormSMulClass R α],
NormSMulClass R (Matrix m n α) | true |
MeasureTheory.VectorMeasure.trim._proof_2 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_2} {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M] {m n : MeasurableSpace α}
(v : MeasureTheory.VectorMeasure α M) (i : Set α),
¬MeasurableSet i → (fun i => if MeasurableSet i then ↑v i else 0) i = 0 | false |
CategoryTheory.MorphismProperty.IsStableUnderColimitsOfShape.rec | Mathlib.CategoryTheory.MorphismProperty.Limits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{J : Type u_1} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} J] →
{motive : W.IsStableUnderColimitsOfShape J → Sort u_2} →
((condition :
∀ (X₁ X₂ : CategoryTheory.Functor J C) (c₁ : CategoryTheory.Limits.Cocone X₁)
(c₂ : CategoryTheory.Limits.Cocone X₂) (h₁ : CategoryTheory.Limits.IsColimit c₁)
(h₁ : CategoryTheory.Limits.IsColimit c₂) (f : X₁ ⟶ X₂),
W.functorCategory J f →
∀ (φ : c₁.pt ⟶ c₂.pt),
(∀ (j : J),
CategoryTheory.CategoryStruct.comp (c₁.ι.app j) φ =
CategoryTheory.CategoryStruct.comp (f.app j) (c₂.ι.app j)) →
W φ) →
motive ⋯) →
(t : W.IsStableUnderColimitsOfShape J) → motive t | false |
TensorPower.multilinearMapToDual._proof_3 | Mathlib.LinearAlgebra.TensorPower.Pairing | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (n : ℕ),
(∀ (x : DecidableEq (Fin n)) (f : Fin n → Module.Dual R M) (φ : Module.Dual R M) (i j : Fin n) (v : Fin n → M),
(Function.update f i φ j) (v j) = Function.update (fun j => (f j) (v j)) i (φ (v i)) j) →
∀ [inst_3 : DecidableEq (Fin n)] (f : Fin n → Module.Dual R M) (i : Fin n) (a : R) (φ : Module.Dual R M),
PiTensorProduct.lift ((MultilinearMap.mkPiRing R (Fin n) 1).compLinearMap (Function.update f i (a • φ))) =
a • PiTensorProduct.lift ((MultilinearMap.mkPiRing R (Fin n) 1).compLinearMap (Function.update f i φ)) | false |
orderOf_eq_zero_iff_eq_zero | Mathlib.GroupTheory.OrderOfElement | ∀ {G₀ : Type u_6} [inst : GroupWithZero G₀] [Finite G₀] {a : G₀}, orderOf a = 0 ↔ a = 0 | true |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.sle_iff_rotate_le_rotate._proof_1_24 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (n : ℕ) (x y : BitVec (n + 1)), ¬x.toNat < 2 ^ n → ¬x.toNat - 2 ^ n ≤ y.toNat + 2 ^ n → False | false |
CategoryTheory.ShortComplex.cyclesMapIso_hom | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) [inst_2 : S₁.HasLeftHomology] [inst_3 : S₂.HasLeftHomology],
(CategoryTheory.ShortComplex.cyclesMapIso e).hom = CategoryTheory.ShortComplex.cyclesMap e.hom | true |
AlgebraicGeometry.Scheme.OpenCover.pullbackCoverAffineRefinementObjIso._proof_7 | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : Y.OpenCover)
(i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰.affineRefinement.openCover).I₀),
CategoryTheory.Limits.HasPullback f (𝒰.affineRefinement.openCover.f i) | false |
Turing.TM2ComputableInTime.casesOn | Mathlib.Computability.TuringMachine.Computable | {α β αΓ βΓ : Type} →
{ea : α → List αΓ} →
{eb : β → List βΓ} →
{f : α → β} →
{motive : Turing.TM2ComputableInTime ea eb f → Sort u} →
(t : Turing.TM2ComputableInTime ea eb f) →
((toTM2ComputableAux : Turing.TM2ComputableAux αΓ βΓ) →
(time : ℕ → ℕ) →
(outputsFun :
(a : α) →
Turing.TM2OutputsInTime toTM2ComputableAux.tm
(List.map toTM2ComputableAux.inputAlphabet.invFun (ea a))
(some (List.map toTM2ComputableAux.outputAlphabet.invFun (eb (f a)))) (time (ea a).length)) →
motive { toTM2ComputableAux := toTM2ComputableAux, time := time, outputsFun := outputsFun }) →
motive t | false |
Lean.Expr.getForallBinderNames._unsafe_rec | Lean.Expr | Lean.Expr → List Lean.Name | false |
Lean.Lsp.LeanPrepareModuleHierarchyParams.mk.injEq | Lean.Data.Lsp.Extra | ∀ (textDocument textDocument_1 : Lean.Lsp.TextDocumentIdentifier),
({ textDocument := textDocument } = { textDocument := textDocument_1 }) = (textDocument = textDocument_1) | true |
BoxIntegral.Prepartition.IsPartition.eq_1 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I), π.IsPartition = ∀ x ∈ I, ∃ J ∈ π, x ∈ J | true |
Set.not_infinite | Mathlib.Data.Finite.Defs | ∀ {α : Type u} {s : Set α}, ¬s.Infinite ↔ s.Finite | true |
HurwitzKernelBounds.isBigO_atTop_F_int_one | Mathlib.NumberTheory.ModularForms.JacobiTheta.Bounds | ∀ (a : UnitAddCircle), ∃ p, 0 < p ∧ HurwitzKernelBounds.F_int 1 a =O[Filter.atTop] fun t => Real.exp (-p * t) | true |
_private.Mathlib.Probability.Process.Filtration.0.MeasureTheory.Filtration.instInfSet._simp_5 | Mathlib.Probability.Process.Filtration | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
_private.Mathlib.LinearAlgebra.Dual.Lemmas.0.Module.finite_dual_iff.match_1_1 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ (K : Type u_2) {V : Type u_1} [inst : CommSemiring K] [inst_1 : AddCommMonoid V] [inst_2 : Module K V]
(motive : Nonempty ((I : Type u_1) × Module.Basis I K V) → Prop) (x : Nonempty ((I : Type u_1) × Module.Basis I K V)),
(∀ (ι : Type u_1) (b : Module.Basis ι K V), motive ⋯) → motive x | false |
CategoryTheory.MorphismProperty.RightFraction.ofInv.congr_simp | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C}
(s s_1 : Y ⟶ X) (e_s : s = s_1) (hs : W s),
CategoryTheory.MorphismProperty.RightFraction.ofInv s hs = CategoryTheory.MorphismProperty.RightFraction.ofInv s_1 ⋯ | true |
InfTopHomClass.toInfHomClass | Mathlib.Order.Hom.BoundedLattice | ∀ {F : Type u_6} {α : Type u_7} {β : Type u_8} {inst : Min α} {inst_1 : Min β} {inst_2 : Top α} {inst_3 : Top β}
{inst_4 : FunLike F α β} [self : InfTopHomClass F α β], InfHomClass F α β | true |
_private.Mathlib.Topology.MetricSpace.Pseudo.Defs.0.Metric.continuousOn_iff._simp_1_1 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β} {a : α} {s : Set α},
ContinuousWithinAt f s a = ∀ ε > 0, ∃ δ > 0, ∀ ⦃x : α⦄, x ∈ s → dist x a < δ → dist (f x) (f a) < ε | false |
Ultrafilter.mem_or_compl_mem | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u} (f : Ultrafilter α) (s : Set α), s ∈ f ∨ sᶜ ∈ f | true |
MeasureTheory.Measure.instIsLocallyFiniteMeasureForallVolumeOfSigmaFinite | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} [inst : Fintype ι] {X : ι → Type u_4} [inst_1 : (i : ι) → TopologicalSpace (X i)]
[inst_2 : (i : ι) → MeasureTheory.MeasureSpace (X i)] [∀ (i : ι), MeasureTheory.SigmaFinite MeasureTheory.volume]
[∀ (i : ι), MeasureTheory.IsLocallyFiniteMeasure MeasureTheory.volume],
MeasureTheory.IsLocallyFiniteMeasure MeasureTheory.volume | true |
Std.DTreeMap.Internal.Impl.WF.below.empty | Std.Data.DTreeMap.Internal.WF.Defs | ∀ {α : Type u} [inst : Ord α] {motive : {β : α → Type v} → (a : Std.DTreeMap.Internal.Impl α β) → a.WF → Prop}
{x : α → Type v}, Std.DTreeMap.Internal.Impl.WF.below ⋯ | true |
DifferentiableWithinAt.add_const | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {s : Set E} (c : F), DifferentiableWithinAt 𝕜 f s x → DifferentiableWithinAt 𝕜 (fun y => f y + c) s x | true |
ConjRootClass.mk_def | 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 : L},
⟦x⟧ = ConjRootClass.mk K x | true |
Int32.minValue_le._simp_1 | Init.Data.SInt.Lemmas | ∀ (a : Int32), (Int32.minValue ≤ a) = True | false |
Function.Bijective.finset_sum | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : Fintype ι] [inst_1 : Fintype κ] [inst_2 : AddCommMonoid M]
(e : ι → κ), Function.Bijective e → ∀ (f : ι → M) (g : κ → M), (∀ (x : ι), f x = g (e x)) → ∑ x, f x = ∑ x, g x | true |
Aesop.newNodeEmoji | Aesop.Tracing | String | true |
HomologicalComplex.XIsoOfEq_hom_comp_d | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₁ p₂ : ι}
(h : p₁ = p₂) (p₃ : ι), CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h).hom (K.d p₂ p₃) = K.d p₁ p₃ | true |
_private.Mathlib.CategoryTheory.Abelian.Injective.Dimension.0.CategoryTheory.injectiveDimension_lt_iff._simp_1_1 | Mathlib.CategoryTheory.Abelian.Injective.Dimension | ∀ {n : WithBot ℕ∞} {m : ℕ}, (n < ↑m + 1) = (n ≤ ↑m) | false |
Aesop.SafeRuleResult | Aesop.Search.Expansion | Type | true |
IsTopologicalAddGroup.rightUniformSpace._proof_1 | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (G : Type u_1) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G],
Filter.Tendsto Prod.swap (Filter.comap (fun p => p.2 + -p.1) (nhds 0)) (Filter.comap (fun p => p.2 + -p.1) (nhds 0)) | false |
Vector.swap_comm | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i j : ℕ} (hi : i < n) (hj : j < n), xs.swap i j hi hj = xs.swap j i hj hi | true |
HasFDerivAt.comp_hasDerivAt_of_eq | Mathlib.Analysis.Calculus.Deriv.Comp | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type w} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {f : 𝕜 → F}
{f' : F} (x : 𝕜) {l : F → E} {l' : F →L[𝕜] E} {y : F},
HasFDerivAt l l' y → HasDerivAt f f' x → y = f x → HasDerivAt (l ∘ f) (l' f') x | true |
CategoryTheory.Functor.mapCommMonCompIso._proof_6 | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u_6} [inst_3 : CategoryTheory.Category.{u_5, u_6} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D] {E : Type u_4}
[inst_6 : CategoryTheory.Category.{u_3, u_4} E] [inst_7 : CategoryTheory.MonoidalCategory E]
[inst_8 : CategoryTheory.BraidedCategory E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D E}
[inst_9 : F.LaxBraided] [inst_10 : G.LaxBraided] {X Y : CategoryTheory.CommMon C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((F.comp G).mapCommMon.map f)
((fun X => CategoryTheory.CommMon.mkIso (CategoryTheory.Iso.refl ((F.comp G).mapCommMon.obj X).X) ⋯ ⋯) Y).hom =
CategoryTheory.CategoryStruct.comp
((fun X => CategoryTheory.CommMon.mkIso (CategoryTheory.Iso.refl ((F.comp G).mapCommMon.obj X).X) ⋯ ⋯) X).hom
((F.mapCommMon.comp G.mapCommMon).map f) | false |
Std.Tactic.BVDecide.LRAT.Internal.Assignment.removeNegAssignment.eq_3 | Std.Tactic.BVDecide.LRAT.Internal.Assignment | Std.Tactic.BVDecide.LRAT.Internal.Assignment.both.removeNegAssignment = Std.Tactic.BVDecide.LRAT.Internal.Assignment.pos | true |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.variance_fun_id_gaussianReal._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {x : E} (c : F), DifferentiableAt 𝕜 (fun x => c) x = True | false |
Lean.JsonRpc.MessageMetaData.responseError.elim | Lean.Data.JsonRpc | {motive : Lean.JsonRpc.MessageMetaData → Sort u} →
(t : Lean.JsonRpc.MessageMetaData) →
t.ctorIdx = 3 →
((id : Lean.JsonRpc.RequestID) →
(code : Lean.JsonRpc.ErrorCode) →
(message : String) →
(data? : Option Lean.Json) → motive (Lean.JsonRpc.MessageMetaData.responseError id code message data?)) →
motive t | false |
Lean.Meta.Grind.SplitSource._sizeOf_inst | Lean.Meta.Tactic.Grind.Types | SizeOf Lean.Meta.Grind.SplitSource | false |
CategoryTheory.Comma.coconeOfPreserves_ι_app_left | Mathlib.CategoryTheory.Limits.Comma | ∀ {J : Type w} [inst : CategoryTheory.Category.{w', w} J] {A : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} A]
{B : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃}
[inst_3 : CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T}
(F : CategoryTheory.Functor J (CategoryTheory.Comma L R))
[inst_4 : CategoryTheory.Limits.PreservesColimit (F.comp (CategoryTheory.Comma.fst L R)) L]
{c₁ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.fst L R))} (t₁ : CategoryTheory.Limits.IsColimit c₁)
(c₂ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.snd L R))) (j : J),
((CategoryTheory.Comma.coconeOfPreserves F t₁ c₂).ι.app j).left = c₁.ι.app j | true |
_private.Init.Data.Char.Ordinal.0.Char.succ?_eq._simp_1_4 | Init.Data.Char.Ordinal | ∀ {a b : UInt32}, (a = a + b) = (b = 0) | false |
_private.Lean.Elab.Tactic.Split.0.Lean.Elab.Tactic.evalSplit.mkCasesHint | Lean.Elab.Tactic.Split | Lean.Expr → Lean.MessageData | true |
PointedCone.dual_zero | Mathlib.Geometry.Convex.Cone.Dual | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommGroup M] [inst_4 : AddCommGroup N] [inst_5 : Module R M] [inst_6 : Module R N]
{p : M →ₗ[R] N →ₗ[R] R}, PointedCone.dual p 0 = ⊤ | true |
Antitone.partMap | Mathlib.Order.Part | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder α] {f : β → γ} {g : α → Part β},
Antitone g → Antitone fun x => Part.map f (g x) | true |
Std.ExtDTreeMap.maxKey! | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → [Inhabited α] → Std.ExtDTreeMap α β cmp → α | true |
Hyperreal.archimedeanClassMk_omega_neg._simp_1 | Mathlib.Analysis.Real.Hyperreal | (ArchimedeanClass.mk Hyperreal.omega < 0) = True | false |
CategoryTheory.Sieve.mk | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
(arrows : CategoryTheory.Presieve X) →
(∀ {Y Z : C} {f : Y ⟶ X}, arrows f → ∀ (g : Z ⟶ Y), arrows (CategoryTheory.CategoryStruct.comp g f)) →
CategoryTheory.Sieve X | true |
Filter.Germ.liftPred_coe | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {p : β → Prop} {f : α → β},
Filter.Germ.LiftPred p ↑f ↔ ∀ᶠ (x : α) in l, p (f x) | true |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.map_revPerm_Ico._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | false |
Multiset.sum_induction_nonempty | Mathlib.Algebra.BigOperators.Group.Multiset.Defs | ∀ {M : Type u_3} [inst : AddCommMonoid M] {s : Multiset M} (p : M → Prop),
(∀ (a b : M), p a → p b → p (a + b)) → s ≠ ∅ → (∀ a ∈ s, p a) → p s.sum | true |
StandardEtalePair.lift._proof_3 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
RingHomClass (Polynomial (Polynomial R) →ₐ[R] S) (Polynomial (Polynomial R)) S | false |
Lean.Server.References.ParentDecl.selectionRange | Lean.Server.References | Lean.Server.References.ParentDecl → Lean.Lsp.Range | true |
IntCast.recOn | Init.Data.Int.Basic | {R : Type u} →
{motive : IntCast R → Sort u_1} → (t : IntCast R) → ((intCast : ℤ → R) → motive { intCast := intCast }) → motive t | false |
CategoryTheory.Limits.Cocone.extendId._proof_1 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor J C} (s : CategoryTheory.Limits.Cocone F)
(j : J),
(s.extend (CategoryTheory.CategoryStruct.id s.pt)).ι.app j =
CategoryTheory.CategoryStruct.comp (s.ι.app j)
(CategoryTheory.Iso.refl (s.extend (CategoryTheory.CategoryStruct.id s.pt)).pt).inv | false |
Aesop.PhaseName.safe.sizeOf_spec | Aesop.Rule.Name | sizeOf Aesop.PhaseName.safe = 1 | true |
MeasurableSpace.separatesPoints_of_measurableSingletonClass | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α] [MeasurableSingletonClass α], MeasurableSpace.SeparatesPoints α | true |
IO.FS.Stream.noConfusionType | Init.System.IO | Sort u → IO.FS.Stream → IO.FS.Stream → Sort u | false |
Lean.Lsp.instToJsonDeleteFile | Lean.Data.Lsp.Basic | Lean.ToJson Lean.Lsp.DeleteFile | true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.edgeDensity_star_not_uniform._proof_1_10 | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {P : Finpartition Finset.univ} {hP : P.IsEquipartition}
{G : SimpleGraph α} [inst_2 : DecidableRel G.Adj] {ε : ℝ} {U V : Finset α} {hU : U ∈ P.parts} {hV : V ∈ P.parts},
U ≠ V →
|↑(G.edgeDensity ((SzemerediRegularity.star hP G ε hU V).biUnion id)
((SzemerediRegularity.star hP G ε hV U).biUnion id)) -
↑(G.edgeDensity (G.nonuniformWitness ε U V) (G.nonuniformWitness ε V U))| ≤
ε / 5 →
ε ≤ |↑(G.edgeDensity (G.nonuniformWitness ε U V) (G.nonuniformWitness ε V U)) - ↑(G.edgeDensity U V)| →
|(∑ ab ∈ (SzemerediRegularity.star hP G ε hU V).product (SzemerediRegularity.star hP G ε hV U),
↑(G.edgeDensity ab.1 ab.2)) /
(↑(SzemerediRegularity.star hP G ε hU V).card * ↑(SzemerediRegularity.star hP G ε hV U).card) -
↑(G.edgeDensity ((SzemerediRegularity.star hP G ε hU V).biUnion id)
((SzemerediRegularity.star hP G ε hV U).biUnion id))| ≤
ε ^ 5 / 49 →
|(∑ ab ∈ (SzemerediRegularity.chunk hP G ε hU).parts.product (SzemerediRegularity.chunk hP G ε hV).parts,
↑(G.edgeDensity ab.1 ab.2)) /
(4 ^ P.parts.card * 4 ^ P.parts.card) -
↑(G.edgeDensity U V)| ≤
ε ^ 5 / 49 →
ε ^ 5 ≤ ε →
3 / 4 * ε ≤
|(∑ ab ∈ (SzemerediRegularity.star hP G ε hU V).product (SzemerediRegularity.star hP G ε hV U),
↑(G.edgeDensity ab.1 ab.2)) /
(↑(SzemerediRegularity.star hP G ε hU V).card * ↑(SzemerediRegularity.star hP G ε hV U).card) -
(∑
ab ∈
(SzemerediRegularity.chunk hP G ε hU).parts.product
(SzemerediRegularity.chunk hP G ε hV).parts,
↑(G.edgeDensity ab.1 ab.2)) /
(4 ^ P.parts.card * 4 ^ P.parts.card)| | false |
_private.Mathlib.Algebra.Polynomial.Identities.0.Polynomial.poly_binom_aux3 | Mathlib.Algebra.Polynomial.Identities | ∀ {R : Type u} [inst : CommRing R] (f : Polynomial R) (x y : R),
Polynomial.eval (x + y) f =
((f.sum fun e a => a * x ^ e) + f.sum fun e a => a * ↑e * x ^ (e - 1) * y) +
f.sum fun e a => a * ↑(Polynomial.polyBinomAux1✝ x y e a) * y ^ 2 | true |
_private.Aesop.Index.RulePattern.0.Aesop.RulePatternIndex.getSingle.match_1 | Aesop.Index.RulePattern | (motive : Option Aesop.Substitution → Sort u_1) →
(__discr : Option Aesop.Substitution) →
((subst : Aesop.Substitution) → motive (some subst)) → ((x : Option Aesop.Substitution) → motive x) → motive __discr | false |
CategoryTheory.Bicategory.LeftAdjoint.noConfusion | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | {P : Sort u_1} →
{B : Type u} →
{inst : CategoryTheory.Bicategory B} →
{a b : B} →
{right : b ⟶ a} →
{t : CategoryTheory.Bicategory.LeftAdjoint right} →
{B' : Type u} →
{inst' : CategoryTheory.Bicategory B'} →
{a' b' : B'} →
{right' : b' ⟶ a'} →
{t' : CategoryTheory.Bicategory.LeftAdjoint right'} →
B = B' →
inst ≍ inst' →
a ≍ a' →
b ≍ b' →
right ≍ right' → t ≍ t' → CategoryTheory.Bicategory.LeftAdjoint.noConfusionType P t t' | false |
CategoryTheory.NatIso.ofComponents'_inv_app | Mathlib.CategoryTheory.NatIso | ∀ {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} (app : (X : C) → F.obj X ≅ G.obj X)
(naturality :
autoParam
(∀ {X Y : C} (f : Y ⟶ X),
CategoryTheory.CategoryStruct.comp (app Y).inv (F.map f) =
CategoryTheory.CategoryStruct.comp (G.map f) (app X).inv)
CategoryTheory.NatIso.ofComponents'._auto_1)
(X : C), (CategoryTheory.NatIso.ofComponents' app naturality).inv.app X = (app X).inv | true |
LieSubmodule.instLieRingModuleSubtypeMem | Mathlib.Algebra.Lie.Submodule | {R : Type u} →
{L : Type v} →
{M : Type w} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] → [inst_4 : LieRingModule L M] → (N : LieSubmodule R L M) → LieRingModule L ↥N | true |
Std.ExtHashMap.getKey.congr_simp | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
(m m_1 : Std.ExtHashMap α β) (e_m : m = m_1) (a a_1 : α) (e_a : a = a_1) (h : a ∈ m), m.getKey a h = m_1.getKey a_1 ⋯ | true |
IsIsometricVAdd | Mathlib.Topology.MetricSpace.IsometricSMul | (M : Type u) → (X : Type w) → [PseudoEMetricSpace X] → [VAdd M X] → Prop | true |
CategoryTheory.sectionsFunctorNatIsoCoyoneda._proof_1 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : Type (max u_2 u_3)) [inst_1 : Unique X]
{X_1 Y : CategoryTheory.Functor C (Type (max u_2 u_3))} (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.sectionsFunctor C).map f)
((fun F => (F.sectionsEquivHom X).toIso) Y).hom =
CategoryTheory.CategoryStruct.comp ((fun F => (F.sectionsEquivHom X).toIso) X_1).hom
((CategoryTheory.coyoneda.obj (Opposite.op ((CategoryTheory.Functor.const C).obj X))).map f) | false |
groupHomology.H2π_comp_map | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B),
CategoryTheory.CategoryStruct.comp (groupHomology.H2π A) (groupHomology.map f φ 2) =
CategoryTheory.CategoryStruct.comp (groupHomology.mapCycles₂ f φ) (groupHomology.H2π B) | true |
Std.IterM.TerminationMeasures.Productive.mk.noConfusion | Init.Data.Iterators.Basic | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{inst : Std.Iterator α m β} →
{P : Sort u} → {it it' : Std.IterM m β} → { it := it } = { it := it' } → (it ≍ it' → P) → P | false |
_private.Mathlib.CategoryTheory.Localization.CalculusOfFractions.0.CategoryTheory.MorphismProperty.LeftFraction.map_compatibility._simp_1_1 | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v_1, u₁} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v_2, u₂} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
{W : D} (h : F.obj Z ⟶ W),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (F.map g) h) =
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.CategoryStruct.comp f g)) h | false |
Complex.le_def | Mathlib.Analysis.Complex.Order | ∀ {z w : ℂ}, z ≤ w ↔ z.re ≤ w.re ∧ z.im = w.im | true |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum._mutual._proof_9 | Lean.Compiler.NameMangling | ∀ (s : String) (p : s.Pos) (res : Lean.Name) (h : ¬p = s.endPos),
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun p res => PSigma.casesOn res fun res n => p) fun _x =>
PSum.casesOn _x (fun _x => PSigma.casesOn _x fun p res => p) fun _x =>
PSigma.casesOn _x fun p₀ res => PSigma.casesOn res fun res acc => PSigma.casesOn acc fun acc ucount => p₀)
String.Pos.instWellFoundedRelation).1
(PSum.inr (PSum.inr ⟨p.next h, ⟨res, ⟨String.singleton (p.get h), 0⟩⟩⟩)) (PSum.inr (PSum.inl ⟨p, res⟩)) | false |
Std.Internal.List.getKey_minKey!_eq_minKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
[inst_4 : Inhabited α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {he : Std.Internal.List.containsKey (Std.Internal.List.minKey! l) l = true},
Std.Internal.List.getKey (Std.Internal.List.minKey! l) l he = Std.Internal.List.minKey l ⋯ | true |
ComplexShape.instAssociative | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ {I : Type u_7} [inst : AddMonoid I] (c : ComplexShape I) [inst_1 : c.TensorSigns], c.Associative c c c c c | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_546 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α),
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w [g (g a)] 1) + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w [g (g a)] 1) <
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length | false |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.«_aux_Mathlib_CategoryTheory_Monoidal_Action_Basic___macroRules_CategoryTheory_MonoidalCategory_MonoidalLeftAction_termλₗ[_]_1» | Mathlib.CategoryTheory.Monoidal.Action.Basic | Lean.Macro | false |
ProbabilityTheory.IdentDistrib.symm | Mathlib.Probability.IdentDistrib | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
[inst_2 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} {f : α → γ} {g : β → γ},
ProbabilityTheory.IdentDistrib f g μ ν → ProbabilityTheory.IdentDistrib g f ν μ | true |
CategoryTheory.Limits.factorThruKernelSubobject.congr_simp | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f] {W : C} (h h_1 : W ⟶ X) (e_h : h = h_1)
(w : CategoryTheory.CategoryStruct.comp h f = 0),
CategoryTheory.Limits.factorThruKernelSubobject f h w = CategoryTheory.Limits.factorThruKernelSubobject f h_1 ⋯ | true |
Submodule.inclusion.eq_1 | Mathlib.Algebra.Module.Submodule.Ker | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p p' : Submodule R M} (h : p ≤ p'), Submodule.inclusion h = LinearMap.codRestrict p' p.subtype ⋯ | true |
Equiv.mul | Mathlib.Algebra.Group.TransferInstance | {α : Type u_2} → {β : Type u_3} → α ≃ β → [Mul β] → Mul α | true |
DFinsupp.comapDomain'._proof_1 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_2} {β : ι → Type u_3} {κ : Type u_1} [inst : (i : ι) → Zero (β i)] (h : κ → ι) {h' : ι → κ},
Function.LeftInverse h' h →
∀ (f : Π₀ (i : ι), β i) (s : { s // ∀ (i : ι), i ∈ s ∨ f.toFun i = 0 }) (x : κ),
x ∈ Multiset.map h' ↑s ∨ f (h x) = 0 | false |
Equiv.commRing._proof_8 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : CommRing β] (n : ℤ) (x : α), e (e.symm (n • e x)) = n • e x | false |
Std.DHashMap.Raw.toList_toArray | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α],
m.WF → m.toArray.toList = m.toList | true |
Batteries.PairingHeapImp.Heap.WF.rec | Batteries.Data.PairingHeap | ∀ {α : Type u_1} {le : α → α → Bool}
{motive : (a : Batteries.PairingHeapImp.Heap α) → Batteries.PairingHeapImp.Heap.WF le a → Prop},
motive Batteries.PairingHeapImp.Heap.nil ⋯ →
(∀ {a : α} {c : Batteries.PairingHeapImp.Heap α} (h : Batteries.PairingHeapImp.Heap.NodeWF le a c),
motive (Batteries.PairingHeapImp.Heap.node a c Batteries.PairingHeapImp.Heap.nil) ⋯) →
∀ {a : Batteries.PairingHeapImp.Heap α} (t : Batteries.PairingHeapImp.Heap.WF le a), motive a t | false |
Nat.log_of_lt | Mathlib.Data.Nat.Log | ∀ {b n : ℕ}, n < b → Nat.log b n = 0 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.