name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Int.ediv_eq_one_of_neg_of_le | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, a < 0 → b ≤ a → a / b = 1 | null | true |
List.prefix_iff_eq_take | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+: l₂ ↔ l₁ = List.take l₁.length l₂ | null | true |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.instQuasiIsoIntι._proof_2 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{K L : CochainComplex C ℤ} (f : K ⟶ L) [inst_2 : CategoryTheory.EnoughInjectives C] [inst_3 : CategoryTheory.Mono f]
(n₀ : ℤ) [inst_4 : K.IsStrictlyGE (n₀ + 1)] [inst_5 : L.IsStrictlyGE (n₀ + 1)] (i : ℤ),
((Homologi... | null | false |
ContMDiff.prodMk_space | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : 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] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
Lean.Compiler.LCNF.Phase.noConfusionType | Lean.Compiler.LCNF.CompilerM | Sort v✝ → Lean.Compiler.LCNF.Phase → Lean.Compiler.LCNF.Phase → Sort v✝ | null | true |
NeZero.pos | Mathlib.Algebra.Order.IsBotOne | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : PartialOrder α] [IsBotZeroClass α] (a : α) [NeZero a], 0 < a | null | true |
FintypeCat.toProfinite._proof_2 | Mathlib.Topology.Category.Profinite.Basic | ∀ (X : FintypeCat),
CompHausLike.ofHom (fun X => TotallyDisconnectedSpace ↑X)
{ toFun := ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)), continuous_toFun := ⋯ } =
CategoryTheory.CategoryStruct.id ↧X.obj | null | false |
Lean.Core.Context.mk._flat_ctor | Lean.CoreM | String →
Lean.FileMap →
Lean.Options →
ℕ →
Lean.Name →
List Lean.OpenDecl →
ℕ →
ℕ →
Lean.Name →
Lean.MacroScope →
Option IO.CancelToken → Std.HashSet Lean.Name → ℕ → Lean.Syntax → Bool → Bool → Lean.Core.Contex... | null | false |
_private.Mathlib.Combinatorics.Matroid.Constructions.0.Matroid.freeOn_isBase_iff._simp_1_3 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {s t : Set α}, (s \ t = ∅) = (s ⊆ t) | null | false |
DistLat.dual_map | Mathlib.Order.Category.DistLat | ∀ {X Y : DistLat} (f : X ⟶ Y), DistLat.dual.map f = DistLat.ofHom (LatticeHom.dual (DistLat.Hom.hom f)) | null | true |
BoundedContinuousFunction.instNonUnitalSeminormedRing._proof_5 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} [inst : TopologicalSpace α] {R : Type u_2} [inst_1 : NonUnitalSeminormedRing R]
(a : BoundedContinuousFunction α R), a * 0 = 0 | null | false |
CategoryTheory.SplitMono.mk | Mathlib.CategoryTheory.EpiMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} →
{f : X ⟶ Y} →
(retraction : Y ⟶ X) →
autoParam (CategoryTheory.CategoryStruct.comp f retraction = CategoryTheory.CategoryStruct.id X)
CategoryTheory.SplitMono.id._autoParam →
CategoryTheory.... | null | true |
CochainComplex.Lifting.cocycle₁.eq_1 | Mathlib.Algebra.Homology.ModelCategory.Lifting | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{A B X Y : CochainComplex C ℤ} {t : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {b : B ⟶ Y} (sq : CategoryTheory.CommSq t i p b)
(hsq : (n : ℤ) → ⋯.LiftStruct) {Q : CochainComplex C ℤ} {π : B ⟶ Q} {hπ : CategoryTheory.CategoryStru... | null | true |
_private.Init.Data.Range.Polymorphic.SInt.0.Int32.instHasModelBitVecOfNatNat._proof_7 | Init.Data.Range.Polymorphic.SInt | ∀ (a a_1 : Int32), a.toBitVec.slt a_1.toBitVec = true ↔ a.toBitVec.slt a_1.toBitVec = true | null | false |
CategoryTheory.GradedObject.braidedCategory._proof_1 | Mathlib.CategoryTheory.GradedObject.Braiding | ∀ {I : Type u_1} [inst : AddCommMonoid I] {C : Type u_2} [inst_1 : CategoryTheory.Category.{u_3, u_2} C]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : ∀ (X₁ X₂ : CategoryTheory.GradedObject I C), X₁.HasTensor X₂]
[inst_4 : CategoryTheory.BraidedCategory C] (x x_1 x_2 : CategoryTheory.GradedObject I C) (x_3... | null | false |
IsometryEquiv.toRealAffineIsometryEquiv._proof_2 | Mathlib.Analysis.Normed.Affine.MazurUlam | ∀ {E : Type u_2} {PE : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : MetricSpace PE] [NormedAddTorsor E PE],
Nonempty PE | null | false |
_private.Mathlib.SetTheory.Cardinal.NatCard.0.Finset.card_le_natCard._simp_1_1 | Mathlib.SetTheory.Cardinal.NatCard | ∀ (α : Type u_3), Nat.card α = Set.univ.ncard | null | false |
CategoryTheory.Functor.IsTriangulated.instAdditive | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] (F : CategoryTheory.Functor C D) [inst_4 : F.CommShift ℤ]
[inst_5 : CategoryTheory.Limits.HasZeroObject C] [in... | null | true |
CategoryTheory.PreOneHypercover.comp_s₀ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {X Y Z : CategoryTheory.PreOneHypercover S}
(f : X.Hom Y) (g : Y.Hom Z) (a : X.I₀), (CategoryTheory.CategoryStruct.comp f g).s₀ a = g.s₀ (f.s₀ a) | null | true |
Algebra.SubmersivePresentation.basisKaehlerOfIsCompl._proof_3 | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | ∀ {R : Type u_2} {S : Type u_1} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ),
Function.Surjective ⇑P.toExtension.toKaehler | null | false |
HomotopyCategory.composableArrowsFunctor._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.SpectralObject | 1 ≤ 1 | null | false |
Lean.Elab.FixedParams.Info.setVarying._unsafe_rec | Lean.Elab.PreDefinition.FixedParams | ℕ → ℕ → Lean.Elab.FixedParams.Info → Lean.Elab.FixedParams.Info | null | false |
CategoryTheory.Limits.PreservesBiproductsOfShape | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
Type w₁ → (F : CategoryTheory.Functor C D) →... | A functor `F` preserves biproducts of shape `J` if it preserves biproducts of `f` for every
`f : J → C`. | true |
BddAbove.convolutionExistsAt | Mathlib.Analysis.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {E : Type uE} {E' : Type uE'} {F : Type uF} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup E'] [inst_2 : NormedAddCommGroup F] {f : G → E} {g : G → E'}
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : NormedSpace 𝕜 ... | A sufficient condition to prove that `f ⋆[L, μ] g` exists.
We assume that the integrand has compact support and `g` is bounded on this support (note that
both properties hold if `g` is continuous with compact support). We also require that `f` is
integrable on the support of the integrand, and that both functions are s... | true |
Lean.Json.«termJson%_» | Lean.Data.Json.Elab | Lean.ParserDescr | Allows to use Json syntax in a Lean file. | true |
Lean.Elab.Term.Do.Code.rec_3 | Lean.Elab.Do.Legacy | {motive_1 : Lean.Elab.Term.Do.Code → Sort u} →
{motive_2 : Array (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) → Sort u} →
{motive_3 : Array (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code) → Sort u} →
{motive_4 : List (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) → Sort u} →
{motive_5 : List (L... | null | false |
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionOfMonoidalFunctorToEndofunctor_actionHomLeft | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
(F : CategoryTheory.Functor C (CategoryTheory.Functor D D)) [inst_3 : F.Monoidal] {d d' : D} (f : d ⟶ d') (c : C),
CategoryTheory.MonoidalCateg... | null | true |
instInhabitedRealizerEmptyCollectionSet | Mathlib.Data.Analysis.Topology | {α : Type u_1} → [inst : TopologicalSpace α] → Inhabited (Compact.Realizer ∅) | null | true |
_private.Lean.Widget.InteractiveDiagnostic.0.Lean.Widget.EmbedFmt.goal.injEq | Lean.Widget.InteractiveDiagnostic | ∀ (ctx : Lean.Elab.ContextInfo) (lctx : Lean.LocalContext) (g : Lean.MVarId) (ctx_1 : Lean.Elab.ContextInfo)
(lctx_1 : Lean.LocalContext) (g_1 : Lean.MVarId),
(Lean.Widget.EmbedFmt.goal✝ ctx lctx g = Lean.Widget.EmbedFmt.goal✝ ctx_1 lctx_1 g_1) =
(ctx = ctx_1 ∧ lctx = lctx_1 ∧ g = g_1) | null | true |
CategoryTheory.HasExt._proof_1 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | IsRightCancelAdd ℤ | null | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastArithShiftRightConst._proof_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | ∀ {w : ℕ} (distance curr : ℕ), curr < w → ¬w - 1 < w → False | null | false |
_private.Mathlib.GroupTheory.Perm.Fin.0.Equiv.Perm.decomposeFin'Symm_uncurry_bijective.match_1_3 | Mathlib.GroupTheory.Perm.Fin | ∀ (n : ℕ) (x : Fin (n + 2) × Equiv.Perm (Fin (n + 1)))
(motive :
(x_1 : Fin (n + 2) × Equiv.Perm (Fin (n + 1))) →
Function.uncurry Equiv.Perm.decomposeFin'Symm x_1 = Function.uncurry Equiv.Perm.decomposeFin'Symm x → Prop)
(x_1 : Fin (n + 2) × Equiv.Perm (Fin (n + 1)))
(h : Function.uncurry Equiv.Perm.de... | null | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._auto_326 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | null | false |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Internal.iter_roo_eq_iter_rco_of_isSome_succ? | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [LT α] [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α] {lo hi : α}
(h : (Std.PRange.succ? lo).isSome = true),
Std.Roo.Internal.iter (lo<...hi) = Std.Rco.Internal.iter ((Std.PRange.succ? lo).get h...hi) | null | true |
ContinuousAlternatingMap.restrictScalarsCLM._proof_4 | Mathlib.Topology.Algebra.Module.Alternating.Topology | ∀ {𝕜 : Type u_1} {ι : Type u_4} {E : Type u_2} {F : Type u_3} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : TopologicalSpace E] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] [inst_7 : IsTopologicalAddGroup F] (𝕜' : Type u_5) [inst_8 : Nontrivia... | null | false |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.exists_quasiIso_injective._proof_1_3 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ (n : ℤ), n - 1 + 1 = n | null | false |
TwoSidedIdeal.map_mono | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} {S : Type u_2} [inst : NonUnitalNonAssocRing R] [inst_1 : NonUnitalNonAssocRing S] {F : Type u_3}
[inst_2 : FunLike F R S] (f : F) {I J : TwoSidedIdeal R}, I ≤ J → TwoSidedIdeal.map f I ≤ TwoSidedIdeal.map f J | null | true |
CategoryTheory.Functor.mapCoconePrecompose._proof_2 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
(H : CategoryTheory.Functor C D) {F G : CategoryTheory.Functor J C} {α : G ⟶ F} {c : CategoryTheory.Limits.Cocone F}
(j : J),... | null | false |
Set.diff_subset_iff | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t u : Set α}, s \ t ⊆ u ↔ s ⊆ t ∪ u | **Alias** of `Set.sdiff_subset_iff`. | true |
Std.ExtHashMap.size_insertManyIfNewUnit_list_le | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α}, (m.insertManyIfNewUnit l).size ≤ m.size + l.length | null | true |
Subsemiring.pointwise_smul_le_pointwise_smul_iff₀._simp_1 | Mathlib.Algebra.Ring.Subsemiring.Pointwise | ∀ {M : Type u_1} {R : Type u_2} [inst : GroupWithZero M] [inst_1 : Semiring R] [inst_2 : MulSemiringAction M R] {a : M},
a ≠ 0 → ∀ {S T : Subsemiring R}, (a • S ≤ a • T) = (S ≤ T) | null | false |
SimpleGraph.Walk.edgeSet_map | Mathlib.Combinatorics.SimpleGraph.Walk.Maps | ∀ {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (f : G →g G') {u v : V} (p : G.Walk u v),
(SimpleGraph.Walk.map f p).edgeSet = Sym2.map ⇑f '' p.edgeSet | null | true |
Std.DTreeMap.Internal.RciSliceData.mk._flat_ctor | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] → Std.DTreeMap.Internal.Impl α β → Std.Rci α → Std.DTreeMap.Internal.RciSliceData α β | null | false |
MeasureTheory.Measure.mem_support_iff | Mathlib.MeasureTheory.Measure.Support | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] {μ : MeasureTheory.Measure X} {x : X},
x ∈ μ.support ↔ ∃ᶠ (u : Set X) in (nhds x).smallSets, 0 < μ u | A point `x` is in the support of measure `μ` iff any neighborhood of `x` contains a
subset with positive measure. | true |
_private.Mathlib.RingTheory.Smooth.Quotient.0.Algebra.FormallySmooth.of_surjective_of_ker_eq_map_of_flat._simp_1_6 | Mathlib.RingTheory.Smooth.Quotient | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {y : M}, (y ∈ f.ker) = (f y = 0) | null | false |
CategoryTheory.Over.isColimitToOver._proof_1 | Mathlib.CategoryTheory.Limits.Over | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] {F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F},
CategoryTheory.Limits.ReflectsColimit (c.toCostructuredArrow.comp (CategoryTheory.CostructuredArrow.toOver F c.pt))
... | null | false |
AddChar.mk.inj | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_1} {inst : AddMonoid A} {M : Type u_2} {inst_1 : Monoid M} {toFun : A → M}
{map_zero_eq_one' : toFun 0 = 1} {map_add_eq_mul' : ∀ (a b : A), toFun (a + b) = toFun a * toFun b} {toFun_1 : A → M}
{map_zero_eq_one'_1 : toFun_1 0 = 1} {map_add_eq_mul'_1 : ∀ (a b : A), toFun_1 (a + b) = toFun_1 a * toFun_1 ... | null | true |
Opens.mayerVietorisSquare._proof_6 | Mathlib.Topology.Sheaves.MayerVietoris | ∀ {T : Type u_1} [inst : TopologicalSpace T] (U V : TopologicalSpace.Opens T),
{ X₁ := U ⊓ V, X₂ := U, X₃ := V, X₄ := U ⊔ V, f₁₂ := CategoryTheory.homOfLE ⋯, f₁₃ := CategoryTheory.homOfLE ⋯,
f₂₄ := CategoryTheory.homOfLE ⋯, f₃₄ := CategoryTheory.homOfLE ⋯, fac := ⋯ }.X₄ =
{ X₁ := U ⊓ V, X₂ := U, X₃ := V, ... | null | false |
_private.Mathlib.Tactic.GCongr.Core.0.Mathlib.Tactic.GCongr.applyGCongrLemma.lambdaBinderNames.match_1 | Mathlib.Tactic.GCongr.Core | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((n : Lean.Name) →
(binderType b : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam n binderType b binderInfo)) →
((x : Lean.Expr) → motive x) → motive e | null | false |
Std.Sat.AIG.RelabelNat.State.mk.inj | Std.Sat.AIG.RelabelNat | ∀ {α : Type} {inst : DecidableEq α} {inst_1 : Hashable α} {decls : Array (Std.Sat.AIG.Decl α)} {idx max : ℕ}
{map : Std.HashMap α ℕ} {inv1 : Std.Sat.AIG.RelabelNat.State.Inv1 max map}
{inv2 : Std.Sat.AIG.RelabelNat.State.Inv2 decls idx map} {max_1 : ℕ} {map_1 : Std.HashMap α ℕ}
{inv1_1 : Std.Sat.AIG.RelabelNat.St... | null | true |
SimpleGraph.ConnectedComponent.supp_inj._simp_1 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} {C D : G.ConnectedComponent}, (C.supp = D.supp) = (C = D) | null | false |
ULift.instCompleteLattice._proof_5 | Mathlib.Order.CompleteLattice.Lemmas | ∀ {α : Type u_2} [inst : CompleteLattice α] (a b : ULift.{u_1, u_2} α), (a ⊔ b).down = a.down ⊔ b.down | null | false |
_private.Mathlib.LinearAlgebra.Finsupp.Span.0.Submodule.mem_sSup_iff_exists_finset.match_1_1 | Mathlib.LinearAlgebra.Finsupp.Span | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{S : Set (Submodule R M)} {m : M} (motive : (∃ s, m ∈ ⨆ i ∈ s, ↑i) → Prop) (x : ∃ s, m ∈ ⨆ i ∈ s, ↑i),
(∀ (s : Finset (Subtype (Membership.mem S))) (hs : m ∈ ⨆ i ∈ s, ↑i), motive ⋯) → motive x | null | false |
_private.Lean.Elab.Tactic.Omega.Frontend.0.Lean.Elab.Tactic.Omega.omegaImpl.match_1 | Lean.Elab.Tactic.Omega.Frontend | (p' : Lean.Elab.Tactic.Omega.Problem) →
(motive : Bool → Option Lean.Elab.Tactic.Omega.Proof → (p'.possible || p'.proveFalse?.isSome) = true → Sort u_1) →
(x : Bool) →
(x_1 : Option Lean.Elab.Tactic.Omega.Proof) →
(x_2 : (p'.possible || p'.proveFalse?.isSome) = true) →
((x_3 : Option Lean.... | null | false |
Lean.Lsp.instToJsonDocumentHighlight | Lean.Data.Lsp.LanguageFeatures | Lean.ToJson Lean.Lsp.DocumentHighlight | null | true |
_private.Mathlib.Computability.NFA.0.NFA.nil_mem_acceptsFrom._simp_1_1 | Mathlib.Computability.NFA | ∀ {α : Type u} {σ : Type v} {M : NFA α σ} {S : Set σ} {x : List α},
(x ∈ M.acceptsFrom S) = ∃ s ∈ M.accept, s ∈ M.evalFrom S x | null | false |
Function.Injective.generalizedCoheytingAlgebra._proof_2 | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Max α] [inst_1 : Min α] [inst_2 : LE α] [inst_3 : LT α] [inst_4 : SDiff α]
[inst_5 : GeneralizedCoheytingAlgebra β] (f : α → β) (hf : Function.Injective f) (le : ∀ {x y : α}, f x ≤ f y ↔ x ≤ y)
(lt : ∀ {x y : α}, f x < f y ↔ x < y) (map_sup : ∀ (a b : α), f (a ⊔ b) = f a ⊔ f ... | null | false |
NNReal.image_coe_uIcc | Mathlib.Basic.NNReal.Basic | ∀ (x y : NNReal), NNReal.toReal '' Set.uIcc x y = Set.uIcc ↑x ↑y | null | true |
Std.Tactic.BVDecide.BVExpr.decEq._proof_125 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (rw : ℕ)
(rlhs : Std.Tactic.BVDecide.BVExpr w) (rrhs : Std.Tactic.BVDecide.BVExpr rw),
¬hash (llhs.shiftLeft lrhs) ≠ hash (rlhs.shiftLeft rrhs) →
∀ (h1 : lw = rw), ¬h1 ▸ lrhs = rrhs → ¬llhs.shiftLeft lrhs = rlhs.shif... | null | false |
Part.bind | Mathlib.Data.Part | {α : Type u_1} → {β : Type u_2} → Part α → (α → Part β) → Part β | The bind operation has value `g (f.get)`, and is defined when all the
parts are defined. | true |
_private.Mathlib.Geometry.Convex.Hull.0.Convexity.mem_convexHull_iff._simp_1_1 | Mathlib.Geometry.Convex.Hull | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | null | false |
List.forall_cons | Mathlib.Data.List.Basic | ∀ {α : Type u} (p : α → Prop) (x : α) (l : List α), List.Forall p (x :: l) ↔ p x ∧ List.Forall p l | null | true |
CategoryTheory.NatTrans.isIso_iff_isIso_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} (τ : F ⟶ G), CategoryTheory.IsIso τ ↔ ∀ (X : C), CategoryTheory.IsIso (τ.app X) | null | true |
Cardinal.cantor' | Mathlib.SetTheory.Cardinal.Basic | ∀ (a : Cardinal.{u_1}) {b : Cardinal.{u_1}}, 1 < b → a < b ^ a | null | true |
Matrix.toLinearMap₂'._proof_1 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ (R : Type u_2) {S₁ : Type u_1} {S₂ : Type u_5} {N₂ : Type u_3} {m : Type u_4} [inst : CommSemiring R]
[inst_1 : AddCommMonoid N₂] [inst_2 : Module R N₂] [inst_3 : Semiring S₁] [inst_4 : Semiring S₂]
[inst_5 : Module S₁ N₂] [inst_6 : Module S₂ N₂] [SMulCommClass S₁ R N₂] [inst_8 : SMulCommClass S₂ R N₂]
[inst_9 ... | null | false |
Mathlib.Tactic.Ring.Common.mul_exp_pos | Mathlib.Tactic.Ring.Common | ∀ {a₁ a₂ : ℕ} (n : ℕ), 0 < a₁ → 0 < a₂ → 0 < a₁ ^ n * a₂ | null | true |
OrderDual.instNatCast._aux_1 | Mathlib.Algebra.Order.Ring.Synonym | {R : Type u_1} → [NatCast R] → NatCast Rᵒᵈ | null | false |
OrderHom.copy | Mathlib.Order.Hom.Basic | {α : Type u_2} →
{β : Type u_3} → [inst : Preorder α] → [inst_1 : Preorder β] → (f : α →o β) → (f' : α → β) → f' = ⇑f → α →o β | Copy of an `OrderHom` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. | true |
_private.Mathlib.Topology.EMetricSpace.BoundedVariation.0.eVariationOn.eVariationOn_inter_Ioi_eq_inter_Ici_of_continuousWithinAt._proof_1_1 | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Set α} {a : α}, s ∩ Set.Ioi a ⊆ s ∩ Set.Ici a | null | false |
_private.Mathlib.GroupTheory.Coxeter.Basic.0.CoxeterSystem.termπ_ | Mathlib.GroupTheory.Coxeter.Basic | Lean.ParserDescr | null | true |
_private.Mathlib.Algebra.Lie.Ideal.0.LieIdeal.coe_map_of_surjective._simp_1_1 | Mathlib.Algebra.Lie.Ideal | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
MeasureTheory.convolution_mono_right_of_nonneg | Mathlib.Analysis.Convolution | ∀ {G : Type uG} {x : G} [inst : MeasurableSpace G] {μ : MeasureTheory.Measure G} [inst_1 : AddGroup G] {f g g' : G → ℝ},
MeasureTheory.ConvolutionExistsAt f g' x (ContinuousLinearMap.lsmul ℝ ℝ) μ →
(∀ (x : G), 0 ≤ f x) →
(∀ (x : G), g x ≤ g' x) →
(∀ (x : G), 0 ≤ g' x) →
MeasureTheory.convo... | null | true |
Std.DTreeMap.Internal.Impl.getD_alter | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h : t.WF) {k k' : α} {fallback : β k'} {f : Option (β k) → Option (β k)},
(Std.DTreeMap.Internal.Impl.alter k f t ⋯).impl.getD k' fallback =
if heq : compare k k' = Ordering.eq the... | null | true |
CategoryTheory.Coyoneda.objOpOp | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(X : C) → CategoryTheory.coyoneda.obj (Opposite.op (Opposite.op X)) ≅ CategoryTheory.yoneda.obj X | Taking the `unop` of morphisms is a natural isomorphism. | true |
_private.Mathlib.Topology.MetricSpace.Infsep.0.Set.einfsep_of_fintype._simp_1_2 | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u_3} {p : Prop} {q : α → Prop}, (p → ∀ (x : α), q x) = ∀ (x : α), p → q x | null | false |
Bundle.Trivialization.continuousOn_proj | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e : Bundle.Trivialization F proj), ContinuousOn proj e.source | null | true |
_private.Init.Data.Int.Gcd.0.Int.gcd_pos_iff._simp_1_2 | Init.Data.Int.Gcd | ∀ {a b : Prop} [Decidable a], (¬(a ∧ b)) = (¬a ∨ ¬b) | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.negY_smul._simp_1_2 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] (P : Fin 3 → R) (u : R), (u • P) 0 = u * P 0 | null | false |
_private.Mathlib.GroupTheory.Perm.Support.0.Equiv.Perm.support_noncommProd._simp_1_3 | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | null | false |
UpperSet.instSetLike.eq_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α], UpperSet.instSetLike = { coe := UpperSet.carrier, coe_injective := ⋯ } | null | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.OwnReason.partialApplication | Lean.Compiler.LCNF.InferBorrow | Lean.FVarId → Lean.Compiler.LCNF.OwnReason✝ | Argument in a partial application. | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.insertList.eq_def | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (l toInsert : List ((a : α) × β a)),
Std.Internal.List.insertList l toInsert =
match toInsert with
| [] => l
| ⟨k, v⟩ :: toInsert => Std.Internal.List.insertList (Std.Internal.List.insertEntry k v l) toInsert | null | true |
ModuleCat.monoidalCategory._proof_4 | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | ∀ {R : Type u_1} [inst : CommRing R] (x x_1 x_2 : ModuleCat R),
ModuleCat.equivalenceSemimoduleCat.functor.map (CategoryTheory.MonoidalCategoryStruct.associator x x_1 x_2).hom =
(((CategoryTheory.Iso.refl
(CategoryTheory.MonoidalCategoryStruct.tensorObj
(ModuleCat.equivalenceSemimodu... | null | false |
ImportGraph.WorkspaceModel.Module.isPrelude | ImportGraph.WorkspaceModel.Model | ImportGraph.WorkspaceModel.Module → Bool | Whether the module has the `prelude` keyword (and hence no implicit `Init` imports). | true |
UpperHalfPlane.hasFPowerSeriesOnBall_cuspFunction | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {h : ℝ} {f : UpperHalfPlane → ℂ} {c : ℕ → ℂ},
0 < h →
AnalyticAt ℂ (UpperHalfPlane.cuspFunction h f) 0 →
(∀ (τ : UpperHalfPlane), HasSum (fun m => c m • Function.Periodic.qParam h ↑τ ^ m) (f τ)) →
HasFPowerSeriesOnBall (UpperHalfPlane.cuspFunction h f) (FormalMultilinearSeries.ofScalars ℂ c) 0 1 | null | true |
ClassGroup.fintypeOfAdmissibleOfFinite._proof_13 | Mathlib.NumberTheory.ClassNumber.Finite | ∀ {R : Type u_2} {S : Type u_1} (K : Type u_3) (L : Type u_4) [inst : EuclideanDomain R] [inst_1 : CommRing S]
[IsDomain S] [inst_3 : Field K] [inst_4 : Field L] [inst_5 : Algebra R K] [IsFractionRing R K] [inst_7 : Algebra K L]
[FiniteDimensional K L] [Algebra.IsSeparable K L] [algRL : Algebra R L] [IsScalarTower ... | null | false |
Matrix.TransvectionStruct._sizeOf_1 | Mathlib.LinearAlgebra.Matrix.Transvection | {n : Type u_1} → {R : Type u₂} → [SizeOf n] → [SizeOf R] → Matrix.TransvectionStruct n R → ℕ | null | false |
Finset.finsuppAntidiag_insert | Mathlib.Algebra.Order.Antidiag.Finsupp | ∀ {ι : Type u_1} {μ : Type u_2} [inst : DecidableEq ι] [inst_1 : AddCommMonoid μ] [inst_2 : Finset.HasAntidiagonal μ]
[inst_3 : DecidableEq μ] {a : ι} {s : Finset ι} (h : a ∉ s) (n : μ),
(insert a s).finsuppAntidiag n =
(Finset.HasAntidiagonal.antidiagonal n).biUnion fun p =>
Finset.map { toFun := fun f =... | null | true |
Submodule.ofAffineSubspace._proof_2 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_2} {V : Type u_1} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
(p : AffineSubspace k V), 0 ∈ p → 0 ∈ ↑p | null | false |
Int.toList_roc_succ_right_eq_cons_map | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, m ≤ n → (m<...=n + 1).toList = (m + 1) :: List.map (fun x => x + 1) (m<...=n).toList | null | true |
BooleanSubalgebra.instHImpCoe._proof_1 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α] {L : BooleanSubalgebra α} (a b : ↥L), ↑a ⇨ ↑b ∈ L | null | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Concrete.0.Equiv.Perm.mem_toCycle_iff_support._simp_1_8 | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} {f : α → α} {a : α} {n : ℕ} {b : α}, (b ∈ List.iterate f a n) = ∃ m < n, b = f^[m] a | null | false |
Finset.smul_finset_union | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : SMul α β] {s₁ s₂ : Finset β} {a : α},
a • (s₁ ∪ s₂) = a • s₁ ∪ a • s₂ | null | true |
CategoryTheory.Mod_.assoc_flip | Mathlib.CategoryTheory.Monoidal.Mod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D]
{A : C} [inst_4 : CategoryTheory.MonObj A] (M : CategoryTheory.Mod D A),
CategoryTh... | **Alias** of `CategoryTheory.Mod.assoc_flip`. | true |
_private.Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup.0.Algebra.GrothendieckGroup.instInv._simp_1 | Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {x y : M × ↥S},
(Localization.r S) x y = ∃ c, ↑c * (↑y.2 * x.1) = ↑c * (↑x.2 * y.1) | null | false |
MeasureTheory.MemLp.const_smul | Mathlib.MeasureTheory.Function.LpSeminorm.SMul | ∀ {α : Type u_1} {F : Type u_2} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup F] {f : α → F} {𝕜 : Type u_3} [inst_1 : NormedRing 𝕜] [inst_2 : MulActionWithZero 𝕜 F]
[IsBoundedSMul 𝕜 F], MeasureTheory.MemLp f p μ → ∀ (c : 𝕜), MeasureTheory.MemLp (c • f) p μ | null | true |
LightCondensed.lanPresheafNatIso.eq_1 | Mathlib.Condensed.Discrete.Colimit | ∀ {F : CategoryTheory.Functor LightProfiniteᵒᵖ (Type u)}
(hF :
(S : LightProfinite) →
CategoryTheory.Limits.IsColimit (F.mapCocone (CategoryTheory.Limits.coconeRightOpOfCone S.asLimitCone))),
LightCondensed.lanPresheafNatIso hF =
CategoryTheory.NatIso.ofComponents
(fun x =>
match x with
... | null | true |
Lean.Meta.ExprConfigCacheKey.ctorIdx | Lean.Meta.Basic | Lean.Meta.ExprConfigCacheKey → ℕ | null | false |
Finset.smulZeroClass | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset | {α : Type u_1} → {β : Type u_2} → [DecidableEq β] → [inst : Zero β] → [SMulZeroClass α β] → SMulZeroClass α (Finset β) | If scalar multiplication by elements of `α` sends `(0 : β)` to zero,
then the same is true for `(0 : Finset β)`. | true |
UInt32.toUInt16_ofNatLT | Init.Data.UInt.Lemmas | ∀ {n : ℕ} (hn : n < UInt32.size), (UInt32.ofNatLT n hn).toUInt16 = UInt16.ofNat n | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.