name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CochainComplex.mappingCocone.ofHom_desc | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {M : CochainComplex C ℤ}
(α : CochainComplex.HomComplex.Cochain K M 0) (β : CochainComplex.HomComplex.Cocycle L M 1)
(hαβ... | null | true |
Aesop.RulePatternCache.rec | Aesop.RulePattern.Cache | {motive : Aesop.RulePatternCache → Sort u} →
((map : Std.HashMap Lean.Expr Aesop.RulePatternCache.Entry) → motive { map := map }) →
(t : Aesop.RulePatternCache) → motive t | null | false |
ContinuousLinearMap.toSpanSingletonCLE._proof_4 | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [inst_4 : IsTopologicalAddGroup E] [inst_5 : ContinuousSMul 𝕜 E],
Continuous ⇑↑(ContinuousLinearMap.toSpanSingletonLE 𝕜 𝕜 E) | null | false |
mem_nhdsWithin_of_mem_nhds | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s t : Set α} {a : α}, s ∈ nhds a → s ∈ nhdsWithin a t | null | true |
CategoryTheory.ShortComplex.gFunctor._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y Z : CategoryTheory.ShortComplex C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.Arrow.homMk (CategoryTheory.CategoryStruct.comp f g).τ₂ (CategoryTheory.CategoryStruct.comp f g).τ₃ ⋯ =
CategoryTheor... | null | false |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.isLive | Lean.Compiler.LCNF.ExplicitRC | Lean.FVarId → Lean.Compiler.LCNF.RcM✝ Bool | null | true |
neg_coe_set | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} {S : Type u_4} [inst : InvolutiveNeg G] [inst_1 : SetLike S G] [NegMemClass S G] {H : S}, -↑H = ↑H | null | true |
Nat.lt_or_gt_of_ne | Init.Data.Nat.Basic | ∀ {a b : ℕ}, a ≠ b → a < b ∨ a > b | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch.isLongestMatchAt | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {pat s : String.Slice} (hpat : pat.isEmpty = false) {pos : String.Pos.Raw}
(h :
String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch✝ pat.copy.toByteArray s.copy.toByteArray
pat.utf8ByteSize pos.byteIdx)
(h' : String.Pos.Raw.IsValidForSlice s (pos.unoffsetBy pat.rawEndPos)),
String.Slice.Patte... | null | true |
Complex.arctan_tan | Mathlib.Analysis.SpecialFunctions.Complex.Arctan | ∀ {z : ℂ}, z ≠ ↑Real.pi / 2 → -(Real.pi / 2) < z.re → z.re ≤ Real.pi / 2 → (Complex.tan z).arctan = z | null | true |
Finset.mem_insert._simp_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | null | false |
AddMonoidHom.eq_of_eqOn_topM | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {f g : M →+ N},
Set.EqOn ⇑f ⇑g ↑⊤ → f = g | null | true |
Lean.Compiler.LCNF.inferBorrow | Lean.Compiler.LCNF.InferBorrow | Lean.Compiler.LCNF.Pass | null | true |
Monovary.add_left | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α]
[inst_3 : PartialOrder β] {f₁ f₂ : ι → α} {g : ι → β}, Monovary f₁ g → Monovary f₂ g → Monovary (f₁ + f₂) g | null | true |
Bundle.TotalSpace.mk_inj | Mathlib.Data.Bundle | ∀ {B : Type u_1} {F : Type u_2} {E : B → Type u_3} {b : B} {y y' : E b}, ⟨b, y⟩ = ⟨b, y'⟩ ↔ y = y' | null | true |
CoalgHom.coe_ofClass | Mathlib.RingTheory.Coalgebra.Hom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : AddCommMonoid B] [inst_4 : Module R B] [inst_5 : CoalgebraStruct R A] [inst_6 : CoalgebraStruct R B]
{F : Type u_6} [inst_7 : FunLike F A B] [inst_8 : CoalgHomClass F R A B] (f : F), ⇑↑f... | null | true |
Function.Embedding.optionEmbeddingEquiv.match_1 | Mathlib.Logic.Embedding.Set | ∀ (α : Type u_2) (β : Type u_1) (f : Option α ↪ β)
(motive : f none ∈ Set.range ⇑(Function.Embedding.some.trans f) → Prop)
(x : f none ∈ Set.range ⇑(Function.Embedding.some.trans f)),
(∀ (x : α) (hx : (Function.Embedding.some.trans f) x = f none), motive ⋯) → motive x | null | false |
_private.Init.Data.List.Impl.0.List.setTR.go.match_1.eq_2 | Init.Data.List.Impl | ∀ {α : Type u_1} (motive : List α → ℕ → Array α → Sort u_2) (head : α) (xs : List α) (acc : Array α)
(h_1 : (x : ℕ) → (x_1 : Array α) → motive [] x x_1)
(h_2 : (head : α) → (xs : List α) → (acc : Array α) → motive (head :: xs) 0 acc)
(h_3 : (x : α) → (xs : List α) → (n : ℕ) → (acc : Array α) → motive (x :: xs) n.... | null | true |
AlgebraicGeometry.Scheme.Pullback.range_snd | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} (f : X ⟶ S) (g : Y ⟶ S),
Set.range ⇑(CategoryTheory.Limits.pullback.snd f g) = ⇑g ⁻¹' Set.range ⇑f | null | true |
ProbabilityTheory.avgRisk_le_iSup_risk | Mathlib.Probability.Decision.Risk.Basic | ∀ {Θ : Type u_1} {𝓧 : Type u_2} {𝓨 : Type u_4} {mΘ : MeasurableSpace Θ} {m𝓧 : MeasurableSpace 𝓧}
{m𝓨 : MeasurableSpace 𝓨} (ℓ : Θ → 𝓨 → ENNReal) (P : ProbabilityTheory.Kernel Θ 𝓧) (κ : ProbabilityTheory.Kernel 𝓧 𝓨)
(π : MeasureTheory.Measure Θ) [MeasureTheory.IsProbabilityMeasure π],
ProbabilityTheory.av... | null | true |
ContinuousLinearMap.toSpanSingleton_smul | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ (R₁ : Type u_1) [inst : Semiring R₁] {M₁ : Type u_4} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R₁ M₁] [inst_4 : TopologicalSpace R₁] [inst_5 : ContinuousSMul R₁ M₁] {α : Type u_9}
[inst_6 : Monoid α] [inst_7 : DistribMulAction α M₁] [inst_8 : ContinuousConstSMul α M₁]
[inst_9 :... | null | true |
Lean.Elab.InfoState.mk.inj | Lean.Elab.InfoTree.Types | ∀ {enabled : Bool} {assignment : Lean.PersistentHashMap Lean.MVarId Lean.Elab.InfoTree}
{lazyAssignment : Lean.PersistentHashMap Lean.MVarId (Task Lean.Elab.InfoTree)}
{trees : Lean.PersistentArray Lean.Elab.InfoTree} {enabled_1 : Bool}
{assignment_1 : Lean.PersistentHashMap Lean.MVarId Lean.Elab.InfoTree}
{laz... | null | true |
Std.Iterators.Types.RepeatIterator.mk.sizeOf_spec | Std.Data.Iterators.Producers.Repeat | ∀ {α : Type u} {f : α → α} [inst : SizeOf α] (next : α), sizeOf { next := next } = 1 + sizeOf next | null | true |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.liminf_mul_le.match_1_1 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {α : Type u_1} {u v : α → EReal} (a b : EReal) (x : α) (motive : v x < b ∧ u x < a ∧ 0 x ≤ u x ∧ 0 x ≤ v x → Prop)
(x_1 : v x < b ∧ u x < a ∧ 0 x ≤ u x ∧ 0 x ≤ v x),
(∀ (x_v : v x < b) (x_u : u x < a) (u_0 : 0 x ≤ u x) (v_0 : 0 x ≤ v x), motive ⋯) → motive x_1 | null | false |
AlgebraicGeometry.Scheme.PartialMap.equiv_toPartialMap_iff_of_isSeparated | Mathlib.AlgebraicGeometry.Birational.RationalMap | ∀ {X Y S : AlgebraicGeometry.Scheme} [inst : X.Over S] [inst_1 : Y.Over S] [AlgebraicGeometry.IsReduced X]
[AlgebraicGeometry.IsSeparated (Y ↘ S)] {f : X.PartialMap Y} {g : X ⟶ Y}
[AlgebraicGeometry.Scheme.PartialMap.IsOver S f] [AlgebraicGeometry.Scheme.Hom.IsOver g S],
f.equiv (AlgebraicGeometry.Scheme.Hom.toPa... | A partial map from a reduced scheme to a separated scheme is equivalent to a morphism
if and only if it is equal to the restriction of the morphism. | true |
Int.pow_dvd_pow_iff | Init.Data.Int.Gcd | ∀ {a b : ℤ} {n : ℕ}, n ≠ 0 → (a ^ n ∣ b ^ n ↔ a ∣ b) | null | true |
CategoryTheory.Functor.functorCategoryMonoidalClosed | Mathlib.CategoryTheory.Monoidal.Closed.FunctorCategory.Complete | (I : Type u₂) →
[inst : CategoryTheory.Category.{v₂, u₂} I] →
(C : Type u₁) →
[inst_1 : CategoryTheory.Category.{v₁, u₁} C] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[CategoryTheory.MonoidalClosed C] →
[∀ (F : CategoryTheory.Functor (CategoryTheory.Discrete I) C),
... | Assuming the existence of certain limits, functors into a monoidal closed category form a
monoidal closed category.
Note: this is defined completely abstractly, and does not have any good definitional properties.
See the TODO in the module docstring.
| true |
BitVec.shiftConcat | Init.Data.BitVec.Basic | {n : ℕ} → BitVec n → Bool → BitVec n | Shifts all bits of `x` to the left by `1` and sets the least significant bit to `b`.
This is a non-dependent version of `BitVec.concat` that does not change the total bitwidth.
| true |
Lean.Omega.Int.le_lt_asymm | Init.Omega.Int | ∀ {x y : ℤ}, y ≤ x → x < y → False | null | true |
HomotopicalAlgebra.BifibrantObject.ιFibrantObjectLocalizerMorphism | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : HomotopicalAlgebra.ModelCategory C] →
CategoryTheory.LocalizerMorphism (HomotopicalAlgebra.weakEquivalences (HomotopicalAlgebra.BifibrantObject C))
(HomotopicalAlgebra.weakEquivalences (HomotopicalAlgebra.FibrantObject C)) | The inclusion `BifibrantObject C ⥤ FibrantObject C`, as a localizer morphism. | true |
SemilatSupCat.delabOf | Mathlib.Order.Category.Semilat | Lean.PrettyPrinter.Delaborator.Delab | This prints `SemilatSupCat.of X` as `↧X`. | true |
Turing.TM1to1.Λ'.normal.injEq | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} (a a_1 : Λ),
(Turing.TM1to1.Λ'.normal a = Turing.TM1to1.Λ'.normal a_1) = (a = a_1) | null | true |
CategoryTheory.Functor.WellOrderInductionData.mk.sizeOf_spec | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | ∀ {J : Type u} [inst : LinearOrder J] [inst_1 : SuccOrder J] {F : CategoryTheory.Functor Jᵒᵖ (Type v)}
[inst_2 : SizeOf J] (succ : (j : J) → ¬IsMax j → F.obj (Opposite.op j) → F.obj (Opposite.op (Order.succ j)))
(map_succ :
∀ (j : J) (hj : ¬IsMax j) (x : F.obj (Opposite.op j)),
(CategoryTheory.ConcreteCat... | null | true |
AddCon.op.eq_1 | Mathlib.GroupTheory.Congruence.Opposite | ∀ {M : Type u_1} [inst : Add M] (c : AddCon M),
c.op = { r := fun a b => c (AddOpposite.unop b) (AddOpposite.unop a), iseqv := ⋯, add' := ⋯ } | null | true |
Lean.Lsp.CompletionItemKind.class.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.CompletionItemKind → Sort u} →
(t : Lean.Lsp.CompletionItemKind) → t.ctorIdx = 6 → motive Lean.Lsp.CompletionItemKind.class → motive t | null | false |
Batteries.Tactic.Congr.Config.mk.inj | Batteries.Tactic.Congr | ∀ {closePre closePost closePre_1 closePost_1 : Bool},
{ closePre := closePre, closePost := closePost } = { closePre := closePre_1, closePost := closePost_1 } →
closePre = closePre_1 ∧ closePost = closePost_1 | null | true |
_private.Mathlib.Data.List.TakeDrop.0.List.takeI_left._simp_1_1 | Mathlib.Data.List.TakeDrop | ∀ (n k : ℕ), (n ≤ n + k) = True | null | false |
RatFunc.ofFractionRing_smul | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : CommRing K] {R : Type u_1} [inst_1 : SMul R (FractionRing (Polynomial K))] (c : R)
(p : FractionRing (Polynomial K)), { toFractionRing := c • p } = c • { toFractionRing := p } | null | true |
_private.Mathlib.Analysis.InnerProductSpace.TensorProduct.0.ContinuousLinearMap.rTensor._simp_3 | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M N : Matrix m n α}, (M = N) = ∀ (i : m) (j : n), M i j = N i j | null | false |
Real.logb_self_eq_one_iff | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b : ℝ}, Real.logb b b = 1 ↔ b ≠ 0 ∧ b ≠ 1 ∧ b ≠ -1 | null | true |
FiniteDimensional.LinearEquiv.quotEquivOfQuotEquiv | Mathlib.LinearAlgebra.FiniteDimensional.Lemmas | {K : Type u} →
{V : Type v} →
[inst : DivisionRing K] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module K V] → [FiniteDimensional K V] → {p q : Subspace K V} → ((V ⧸ p) ≃ₗ[K] ↥q) → (V ⧸ q) ≃ₗ[K] ↥p | Given the subspaces `p q`, if `p.quotient ≃ₗ[K] q`, then `q.quotient ≃ₗ[K] p` | true |
IsIsometricSMul.mk | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {M : Type u} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : SMul M X],
(∀ (c : M), Isometry fun x => c • x) → IsIsometricSMul M X | null | true |
HahnSeries.instCommSemiring | Mathlib.RingTheory.HahnSeries.Multiplication | {Γ : Type u_1} →
{R : Type u_3} →
[inst : AddCommMonoid Γ] →
[inst_1 : PartialOrder Γ] → [IsOrderedCancelAddMonoid Γ] → [inst : CommSemiring R] → CommSemiring (HahnSeries Γ R) | null | true |
AddMagma.AssocRel.casesOn | Mathlib.Algebra.Free | ∀ {α : Type u} [inst : Add α] {motive : (a a_1 : α) → AddMagma.AssocRel α a a_1 → Prop} {a a_1 : α}
(t : AddMagma.AssocRel α a a_1),
(∀ (x y z : α), motive (x + y + z) (x + (y + z)) ⋯) →
(∀ (w x y z : α), motive (w + (x + y + z)) (w + (x + (y + z))) ⋯) → motive a a_1 t | null | false |
CategoryTheory.Functor.IsCartesian.map_self | Mathlib.CategoryTheory.FiberedCategory.Cartesian | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
(p : CategoryTheory.Functor 𝒳 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [inst_2 : p.IsCartesian f φ],
CategoryTheory.Functor.IsCartesian.map p f φ φ = CategoryTheory.CategoryStruct.id... | null | true |
IsLowerModularLattice.mk | Mathlib.Order.ModularLattice | ∀ {α : Type u_2} [inst : Lattice α], (∀ {a b : α}, a ⋖ a ⊔ b → a ⊓ b ⋖ b) → IsLowerModularLattice α | null | true |
Aesop.CompleteMatch.noConfusionType | Aesop.Forward.Match.Types | Sort u → Aesop.CompleteMatch → Aesop.CompleteMatch → Sort u | null | false |
Complex.ofReal_tanh_ofReal_re | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), ↑(Complex.tanh ↑x).re = Complex.tanh ↑x | null | true |
ComplexShape.Embedding.AreComplementary.Boundary.fst_inj | Mathlib.Algebra.Homology.Embedding.AreComplementary | ∀ {ι : Type u_1} {ι₁ : Type u_2} {ι₂ : Type u_3} {c : ComplexShape ι} {c₁ : ComplexShape ι₁} {c₂ : ComplexShape ι₂}
{e₁ : c₁.Embedding c} {e₂ : c₂.Embedding c} {ac : e₁.AreComplementary e₂} {i₁ i₁' : ι₁} {i₂ : ι₂},
ac.Boundary i₁ i₂ → ac.Boundary i₁' i₂ → i₁ = i₁' | null | true |
Action.diagonalSuccIsoTensorTrivial.eq_1 | Mathlib.CategoryTheory.Action.Monoidal | ∀ (G : Type u) [inst : Group G],
Action.diagonalSuccIsoTensorTrivial G 0 =
Action.diagonalOneIsoLeftRegular G ≪≫
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (Action.leftRegular G)).symm ≪≫
CategoryTheory.MonoidalCategory.tensorIso (CategoryTheory.Iso.refl (Action.leftRegular G))
(Ac... | null | true |
ValuationSubring.coe_unitGroupMulEquiv_symm_apply | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K) (a : (↥A)ˣ), ↑↑(A.unitGroupMulEquiv.symm a) = ↑↑a | null | true |
ModularForm.E₄._proof_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Basic | 3 ≤ 4 | null | false |
ArchimedeanClass.FiniteResidueField.mk_eq_mk | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K]
{x y : ArchimedeanClass.FiniteElement K},
ArchimedeanClass.FiniteResidueField.mk x = ArchimedeanClass.FiniteResidueField.mk y ↔
0 < ArchimedeanClass.mk (↑x - ↑y) | null | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.interSmallerFnₘ.match_1.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u_2} {β : α → Type u_1} (motive : Option ((a : α) × β a) → Sort u_3) (kv' : (a : α) × β a)
(h_1 : (kv' : (a : α) × β a) → motive (some kv')) (h_2 : Unit → motive none),
(match some kv' with
| some kv' => h_1 kv'
| none => h_2 ()) =
h_1 kv' | null | true |
Lean.Doc.Parser.InlineCtxt.allowNewlines | Lean.DocString.Parser | Lean.Doc.Parser.InlineCtxt → Bool | Are newlines allowed here? | true |
CategoryTheory.InjectiveResolution.instIsLECochainComplexOfNatInt | Mathlib.CategoryTheory.Abelian.Injective.Extend | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X : C}
(R : CategoryTheory.InjectiveResolution X), R.cochainComplex.IsLE 0 | null | true |
AffineSubspace.topEquiv | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | (k : Type u_1) →
(V : Type u_2) →
(P : Type u_3) →
[inst : Ring k] → [inst_1 : AddCommGroup V] → [inst_2 : Module k V] → [S : AddTorsor V P] → ↥⊤ ≃ᵃ[k] P | The top affine subspace is linearly equivalent to the affine space.
This is the affine version of `Submodule.topEquiv`. | true |
selfAdjoint.instPowSubtypeMemAddSubgroupInt | Mathlib.Algebra.Star.SelfAdjoint | {R : Type u_1} → [inst : Field R] → [inst_1 : StarRing R] → Pow ↥(selfAdjoint R) ℤ | null | true |
_private.Mathlib.Data.Num.Lemmas.0.Num.commSemiring._proof_17 | Mathlib.Data.Num.Lemmas | ∀ (a b c : Num), (↑a + ↑b) * ↑c = ↑a * ↑c + ↑b * ↑c | null | false |
List.foldlM_cons | Init.Data.List.Control | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} [inst : Monad m] {f : β → α → m β} {b : β} {a : α}
{l : List α},
List.foldlM f b (a :: l) = do
let init ← f b a
List.foldlM f init l | null | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.uniformContinuous_ofUniformFun._simp_1_1 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {f : α → β} {x : Filter α} {y : ι → Filter β},
Filter.Tendsto f x (⨅ i, y i) = ∀ (i : ι), Filter.Tendsto f x (y i) | null | false |
MultilinearMap.currySum_smul | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ {R : Type uR} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : Module R M₂] {N : ι ⊕ ι' → Type u_1} [inst_3 : (i : ι ⊕ ι') → AddCommMonoid (N i)]
[inst_4 : (i : ι ⊕ ι') → Module R (N i)] (r : R) (f : MultilinearMap R N M₂), (r • f).currySum = r • f.currySu... | null | true |
Lean.Meta.SolveByElim.ApplyRulesConfig.transparency | Lean.Meta.Tactic.SolveByElim | Lean.Meta.SolveByElim.ApplyRulesConfig → Lean.Meta.TransparencyMode | Transparency mode for calls to `apply`. | true |
_private.Mathlib.Tactic.NormNum.Basic.0.Mathlib.Meta.NormNum.Result.add.nnratArm.match_1 | Mathlib.Tactic.NormNum.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
{b : Q(«$α»)} →
(dsα : Q(DivisionSemiring «$α»)) →
(motive : ℚ × (n : Q(ℕ)) × (d : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsNNRat «$b» «$n» «$d») → Sort u_1) →
(x : ℚ × (n : Q(ℕ)) × (d : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsNNRat «$b» «$n» «$d»)) →
((qb... | null | false |
HomologicalComplex.quasiIso_ιTruncLE_iff_isSupported | Mathlib.Algebra.Homology.Embedding.TruncLEHomology | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : e.IsTruncLE] [inst_3 : ∀ (i' : ι'), K.HasHomology i']
[inst_4 :... | null | true |
_private.Mathlib.Algebra.Group.Submonoid.Saturation.0.SaturatedSubmonoid.instInfSet._simp_2 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : MulOneClass M] {S : Set (Submonoid M)} {x : M}, (x ∈ sInf S) = ∀ p ∈ S, x ∈ p | null | false |
isUpperSet_subtype_iff_isRelUpperSet | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {P : α → Prop} [inst : LE α] {s : Set { x // P x }}, IsUpperSet s ↔ IsRelUpperSet (Subtype.val '' s) P | null | true |
IsUpperSet.isLowerSet_preimage_coe | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : LE α] {s t : Set α},
IsUpperSet s → (IsLowerSet (Subtype.val ⁻¹' t) ↔ ∀ b ∈ s, ∀ c ∈ t, b ≤ c → b ∈ t) | null | true |
Lake.ComputeHash.mk.noConfusion | Lake.Build.Trace | {α : Type u} →
{m : outParam (Type → Type v)} →
{P : Sort u_1} →
{computeHash computeHash' : α → m Lake.Hash} →
{ computeHash := computeHash } = { computeHash := computeHash' } → (computeHash ≍ computeHash' → P) → P | null | false |
ByteSlice.ofByteArray | Std.Data.ByteSlice | ByteArray → ByteSlice | Creates a new ByteSlice of a ByteArray
| true |
Lean.Meta.Match.State.noConfusionType | Lean.Meta.Match.Match | Sort u → Lean.Meta.Match.State → Lean.Meta.Match.State → Sort u | null | false |
add_left_strictMono | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a : α} [inst : Add α] [inst_1 : Preorder α] [AddRightStrictMono α], StrictMono fun x => x + a | null | true |
Std.Tactic.BVDecide.Normalize.Bool.ite_same_then' | Std.Tactic.BVDecide.Normalize.Bool | ∀ (c t e : Bool), (t == bif c then t else e) = (c || t == e) | null | true |
Nat.card_ne_zero | Mathlib.SetTheory.Cardinal.Finite | ∀ {α : Type u_1}, Nat.card α ≠ 0 ↔ Nonempty α ∧ Finite α | null | true |
Nat.prodMk_mem_divisorsAntidiag | Mathlib.NumberTheory.Divisors | ∀ {n x y : ℕ}, n ≠ 0 → ((x, y) ∈ n.divisorsAntidiagonal ↔ x * y = n) | null | true |
ENNReal.ofReal_lt_one._simp_1 | Mathlib.Basic.ENNReal.Real | ∀ {p : ℝ}, (ENNReal.ofReal p < 1) = (p < 1) | null | false |
Finsupp.domCongr_symm | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] (e : α ≃ β),
(Finsupp.domCongr e).symm = Finsupp.domCongr e.symm | null | true |
CategoryTheory.GrothendieckTopology.WEqualsLocallyBijective.iff | Mathlib.CategoryTheory.Sites.LocallyBijective | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {J : CategoryTheory.GrothendieckTopology C} {A : Type u'}
{inst_1 : CategoryTheory.Category.{v', u'} A} {FA : A → A → Type u_1} {CA : A → Type w'}
{inst_2 : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)} {inst_3 : CategoryTheory.ConcreteCategory A FA}
[self : ... | null | true |
Matrix.isHyperbolic_neg_iff | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : Preorder R] {m : Matrix (Fin 2) (Fin 2) R},
(-m).IsHyperbolic ↔ m.IsHyperbolic | null | true |
Lean.Compiler.LCNF.Pass.ctorIdx | Lean.Compiler.LCNF.PassManager | Lean.Compiler.LCNF.Pass → ℕ | null | false |
exists_lt_of_not_minimal | Mathlib.Order.Minimal | ∀ {α : Type u_2} {P : α → Prop} {x : α} [inst : Preorder α], P x → ¬Minimal P x → ∃ y < x, P y | **Alias** of the forward direction of `not_minimal_iff_exists_lt`. | true |
_private.Mathlib.Data.Sum.Basic.0.Sum.getLeft_eq_getLeft?._proof_1_5 | Mathlib.Data.Sum.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : α ⊕ β} (h₁ : x.isLeft = true) (h₂ : x.getLeft?.isSome = true),
x.getLeft h₁ = x.getLeft?.get h₂ | null | false |
Option.pfilter_join | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o : Option (Option α)} {p : (a : α) → o.join = some a → Bool},
o.join.pfilter p = (o.pfilter fun o' h => o'.pelim false fun a ha => p a ⋯).join | null | true |
CategoryTheory.SymmetricRelation.map._proof_1 | Mathlib.CategoryTheory.EquivalenceRelation | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {R X : C} {p₁ p₂ : R ⟶ X} (e : CategoryTheory.SymmetricRelation p₁ p₂)
(F : CategoryTheory.Functor C D), CategoryTheory.CategoryStruct.comp (F.map e.s) (F.map p₁) = F.map p₂ | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Const.isEmpty_filterMap_eq_false._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {o : Option α}, (o ≠ none) = (o.isSome = true) | null | false |
ImportGraph.WorkspaceModel.Package.rec | ImportGraph.WorkspaceModel.Model | {motive : ImportGraph.WorkspaceModel.Package → Sort u} →
((toBasePackage : ImportGraph.Lake.BasePackage) →
(deps : ImportGraph.PackageBitset) →
(libs : ImportGraph.LibraryBitset) →
(mods : ImportGraph.ModuleBitset) →
motive { toBasePackage := toBasePackage, deps := deps, libs := li... | null | false |
CategoryTheory.Limits.CokernelCofork.condition | 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} (s : CategoryTheory.Limits.CokernelCofork f),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.Cofork.π s) = 0 | null | true |
ContinuousLinearEquiv.iteratedFDerivWithin_comp_right | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {s : Set E} (g : G ≃L[𝕜] E) (f : E →... | The iterated derivative within a set of the composition with a linear equiv on the right is
obtained by composing the iterated derivative with the linear equiv. | true |
Matrix.IsFiniteCartan.diag | Mathlib.LinearAlgebra.Matrix.Cartan.Basic | ∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] {M : Matrix ι ι ℤ}, M.IsFiniteCartan → ∀ (i : ι), M i i = 2 | null | true |
Lean.Meta.ArgsPacker.Mutual.unpack | Lean.Meta.ArgsPacker | ℕ → Lean.Expr → Option (ℕ × Lean.Expr) | Unpacks a mutually packed argument created with `Mutual.mk` returning the
argument and function index.
Throws an error if the expression is not of that form.
| true |
_private.Mathlib.Algebra.Lie.Basis.Base.0.LieAlgebra.exists_basis_of_base._simp_1_8 | Mathlib.Algebra.Lie.Basis.Base | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
_private.Lean.Compiler.LCNF.Types.0.Lean.Compiler.LCNF.toLCNFType.visitForall._sparseCasesOn_4 | Lean.Compiler.LCNF.Types | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
TopologicalSpace.Opens.instUniqueOfIsEmpty._proof_1 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_1} [inst : TopologicalSpace α] [IsEmpty α] (x : TopologicalSpace.Opens α), x = default | null | false |
CategoryTheory.MorphismProperty.commShift_Q' | Mathlib.CategoryTheory.Shift.Localization | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(W : CategoryTheory.MorphismProperty C) →
(A : Type w) →
[inst_1 : AddMonoid A] →
[inst_2 : CategoryTheory.HasShift C A] →
[inst_3 : W.IsCompatibleWithShift A] → [inst_4 : W.HasLocalization] → W.Q'.CommShift A | The localization functor `W.Q' : C ⥤ W.Localization'` is compatible with the shift. | true |
AddEquiv.neg_apply | Mathlib.Algebra.Group.Units.Equiv | ∀ (G : Type u_6) [inst : SubtractionCommMonoid G] (a : G), (AddEquiv.neg G) a = -a | null | true |
csSup_inter_le | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s t : Set α},
BddAbove s → BddAbove t → (s ∩ t).Nonempty → sSup (s ∩ t) ≤ sSup s ⊓ sSup t | The supremum of an intersection of two sets is bounded by the minimum of the suprema of each
set, if all sets are bounded above and nonempty. | true |
Lean.getStructureParentInfo | Lean.Structure | Lean.Environment → Lean.Name → Array Lean.StructureParentInfo | Gets information for all the parents that appear in the `extends` clause. | true |
List.map_length_splitWrtComposition | Mathlib.Combinatorics.Enumerative.Composition | ∀ {α : Type u_1} (l : List α) (c : Composition l.length), List.map List.length (l.splitWrtComposition c) = c.blocks | When one splits a list along a composition `c`, the lengths of the sublists thus created are
given by the block sizes in `c`. | true |
Filter.hyperfilter.congr_simp | Mathlib.Analysis.Real.Hyperreal | ∀ (α : Type u) [inst : Infinite α], Filter.hyperfilter α = Filter.hyperfilter α | null | true |
right_le_lineMap_iff_le | Mathlib.LinearAlgebra.AffineSpace.Ordered | ∀ {k : Type u_1} {E : Type u_2} [inst : Field k] [inst_1 : LinearOrder k] [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} {r : k}, r < 1 → (b ≤ (AffineMap.lineMap a b) r ↔ b ≤ a) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.