name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Nat.cast_finprod_mem | Mathlib.Algebra.BigOperators.Finprod | ∀ {ι : Type u_3} {s : Set ι},
s.Finite →
∀ {R : Type u_7} [inst : CommSemiring R] (f : ι → ℕ),
↑(∏ᶠ (x : ι) (_ : x ∈ s), f x) = ∏ᶠ (x : ι) (_ : x ∈ s), ↑(f x) | null | true |
Ring.DirectLimit.of._proof_2 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_2) [inst_1 : (i : ι) → CommRing (G i)]
(f : (i j : ι) → i ≤ j → G i → G j) (i : ι),
(Ideal.Quotient.mk
(Ideal.span
{a |
(∃ i j, ∃ (H : i ≤ j), ∃ x, FreeCommRing.of ⟨j, f i j H x⟩ - FreeCommRing.of ⟨i, x⟩ = a) ∨
(∃ i, Fr... | null | false |
LieAlgebra.isNilpotent_range_ad_iff._simp_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieRing.IsNilpotent ↥(LieAlgebra.ad R L).range = LieRing.IsNilpotent L | null | false |
upperClosure_eq_bot | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Set α}, ¬BddBelow s → upperClosure s = ⊥ | null | true |
Lean.Doc.instFromDocArgNat | Lean.Elab.DocString | Lean.Doc.FromDocArg ℕ | null | true |
String.Pos.mk.sizeOf_spec | Init.Data.String.Defs | ∀ {s : String} (offset : String.Pos.Raw) (isValid : String.Pos.Raw.IsValid s offset),
sizeOf { offset := offset, isValid := isValid } = 1 + sizeOf offset + sizeOf isValid | null | true |
Int64.ne_iff_toBitVec_ne | Init.Data.SInt.Lemmas | ∀ {a b : Int64}, a ≠ b ↔ a.toBitVec ≠ b.toBitVec | null | true |
NumberField.discr_mem_differentIdeal | Mathlib.NumberTheory.NumberField.Discriminant.Different | ∀ (K : Type u_1) (𝒪 : Type u_2) [inst : Field K] [inst_1 : NumberField K] [inst_2 : CommRing 𝒪] [inst_3 : Algebra 𝒪 K]
[IsFractionRing 𝒪 K] [inst_5 : IsDedekindDomain 𝒪] [inst_6 : CharZero 𝒪] [Module.Finite ℤ 𝒪],
↑(NumberField.discr K) ∈ differentIdeal ℤ 𝒪 | null | true |
CategoryTheory.MonoidalOpposite.noConfusionType | Mathlib.CategoryTheory.Monoidal.Opposite | Sort u → {C : Type u₁} → Cᴹᵒᵖ → {C' : Type u₁} → C'ᴹᵒᵖ → Sort u | null | false |
ProbabilityTheory.Kernel.Invariant.eq_1 | Mathlib.Probability.Kernel.Invariance | ∀ {α : Type u_1} {mα : MeasurableSpace α} (κ : ProbabilityTheory.Kernel α α) (μ : MeasureTheory.Measure α),
κ.Invariant μ = (μ.bind ⇑κ = μ) | null | true |
_private.Init.Data.Nat.Power2.Basic.0.Nat.nextPowerOfTwo.go | Init.Data.Nat.Power2.Basic | ℕ → (power : ℕ) → power > 0 → ℕ | null | true |
_private.Lean.Meta.Tactic.Try.Collect.0.Lean.Meta.Try.Collector.saveFunInd.match_1 | Lean.Meta.Tactic.Try.Collect | (motive : Option Lean.Meta.FunIndInfo → Sort u_1) →
(__do_lift : Option Lean.Meta.FunIndInfo) →
((funIndInfo : Lean.Meta.FunIndInfo) → motive (some funIndInfo)) →
((x : Option Lean.Meta.FunIndInfo) → motive x) → motive __do_lift | null | false |
_private.Mathlib.MeasureTheory.Measure.AddContent.0.MeasureTheory.AddContent.onIoc._proof_8 | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} [inst : LinearOrder α] (v u' v' : α), v ∈ Set.Ioc u' v' → v' ≤ v → v = v' | null | false |
Lean.Elab.Term.SyntheticMVarDecl.noConfusion | Lean.Elab.Term.TermElabM | {P : Sort u} →
{t t' : Lean.Elab.Term.SyntheticMVarDecl} → t = t' → Lean.Elab.Term.SyntheticMVarDecl.noConfusionType P t t' | null | false |
CategoryTheory.MonoidalSingleObj.endMonoidalStarFunctorEquivalence | Mathlib.CategoryTheory.Bicategory.SingleObj | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.EndMonoidal (CategoryTheory.MonoidalSingleObj.star C) ≌ C | The equivalence between the endomorphisms of the single object
when we promote a monoidal category to a single object bicategory,
and the original monoidal category.
| true |
LieModule.genWeightSpace_neg_zsmul_add_ne_bot | Mathlib.Algebra.Lie.Weights.Chain | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {M : Type u_3}
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] [inst_8 : IsAddTorsionFree R] [inst_9 : IsDomain R]
[inst_10 : ... | null | true |
Stream'.Seq.lt_length_iff | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {s : Stream'.Seq α} {n : ℕ} {h : s.Terminates}, n < s.length h ↔ ∃ a, a ∈ s.get? n | The statement of `length_le_iff` assumes that the sequence terminates. For a
statement of the where the sequence is not known to terminate see `length_le_iff'`. | true |
Lean.IR.LocalContext.isParam | Lean.Compiler.IR.Basic | Lean.IR.LocalContext → Lean.IR.Index → Bool | null | true |
FinEnum.card_punit | Mathlib.Data.FinEnum | FinEnum.card PUnit.{u_1 + 1} = 1 | null | true |
_private.Mathlib.CategoryTheory.Sites.Sieves.0.CategoryTheory.Sieve.pullback_comp._simp_1_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {R S : CategoryTheory.Sieve X},
(R = S) = ∀ ⦃Y : C⦄ (f : Y ⟶ X), R.arrows f ↔ S.arrows f | null | false |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.integrable_gaussianPDFReal._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (0 < a) = (a ≠ 0) | null | false |
Int.ediv_mul_add_emod | Init.Data.Int.DivMod.Bootstrap | ∀ (a b : ℤ), a / b * b + a % b = a | null | true |
PiNat.mem_cylinder_iff_dist_le | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} {x y : (n : ℕ) → E n} {n : ℕ}, y ∈ PiNat.cylinder x n ↔ dist y x ≤ (1 / 2) ^ n | null | true |
String.Pos.offset_add_slice | Init.Data.String.Basic | ∀ {s : String} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁}, p₀.offset + s.slice p₀ p₁ h = p₁.offset | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.tuple._regBuiltin.Lean.Parser.Term.tuple.parenthesizer_13 | Lean.Parser.Term | IO Unit | null | false |
TangentBundle.chartAt | Mathlib.Geometry.Manifold.VectorBundle.Tangent | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_4} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_6}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [inst_6 : IsManifold I 1 M] (p : Tangen... | null | true |
Fin2.fz.noConfusion | Mathlib.Data.Fin.Fin2 | {P : Sort u} → {n n' : ℕ} → n + 1 = n' + 1 → Fin2.fz ≍ Fin2.fz → (n = n' → P) → P | null | false |
_private.Mathlib.RingTheory.Unramified.LocalStructure.0.Algebra.IsUnramifiedAt.exists_hasStandardEtaleSurjectionOn_of_exists_adjoin_singleton_eq_top_aux₂._simp_1_2 | Mathlib.RingTheory.Unramified.LocalStructure | ∀ {R : Type uR} {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : CommSemiring B] [inst_4 : Algebra R B] (b : B), 1 ⊗ₜ[R] b = (algebraMap B (TensorProduct R A B)) b | null | false |
dotProduct_self_star_nonneg._simp_1 | Mathlib.LinearAlgebra.Matrix.DotProduct | ∀ {n : Type u_2} {R : Type u_4} [inst : Fintype n] [inst_1 : PartialOrder R] [inst_2 : NonUnitalRing R]
[inst_3 : StarRing R] [StarOrderedRing R] (v : n → R), (0 ≤ v ⬝ᵥ star v) = True | null | false |
Matroid.RankFinite.exists_finite_isBase | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} [self : M.RankFinite], ∃ B, M.IsBase B ∧ B.Finite | There is a finite base | true |
CategoryTheory.Limits.Cocone.toCostructuredArrowCocone._proof_2 | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {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] {D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D]
{K : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone K) (F : CategoryTheory.Functor C D) {X : D}
(f : F.obj c.p... | null | false |
CategoryTheory.MorphismProperty.TransfiniteCompositionOfShape.recOn | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
[inst_3 : OrderBot J] →
[inst_4 : WellFoundedLT J] →
{X Y : C} →
... | null | false |
_private.Mathlib.Order.BooleanAlgebra.Set.0.Set.ssubset_iff_sdiff_singleton._proof_1_1 | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α}, s ⊂ t ↔ ∃ a ∈ t, s ⊆ t \ {a} | null | false |
CategoryTheory.Limits.MultispanIndex.sndSigmaMapOfIsColimit.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left}
(d : CategoryTheory.Limits.Cofan I.right) (hc : CategoryTheory.Limits.IsColimit c),
I.sndSigmaMapOfIsColimit d hc =
Catego... | null | true |
Nat.max_left_comm | Init.Data.Nat.Lemmas | ∀ (a b c : ℕ), max a (max b c) = max b (max a c) | null | true |
Affine.Simplex.height.eq_1 | Mathlib.Geometry.Euclidean.Altitude | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (i : Fin (n + 1)),
s.height i = dist (s.points i) (s.altitudeFoot i) | null | true |
_private.Mathlib.Dynamics.TopologicalEntropy.Semiconj.0.Dynamics.IsDynCoverOf.preimage._simp_1_4 | Mathlib.Dynamics.TopologicalEntropy.Semiconj | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : α → Prop} {q : β → Prop},
(∃ b, (∃ a, p a ∧ f a = b) ∧ q b) = ∃ a, p a ∧ q (f a) | null | false |
Aesop.VariableMap.addHyp | Aesop.Forward.State | Aesop.VariableMap → Aesop.Slot → Aesop.Hyp → Aesop.BaseM (Aesop.VariableMap × Bool) | Add a hypothesis `hyp`. Precondition: `hyp` matches the premise of slot
`slot` with substitution `hyp.subst` (and hence `hyp.subst` contains a mapping
for each variable in `slot.common`). Returns `true` if the variable map
changed. | true |
Lean.Elab.Tactic.BVDecide.Frontend.BVCheck.mkContext | Lean.Elab.Tactic.BVDecide.Frontend.BVCheck | System.FilePath →
Lean.Elab.Tactic.BVDecide.Frontend.BVDecideConfig →
Lean.Elab.TermElabM Lean.Elab.Tactic.BVDecide.Frontend.TacticContext | null | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.process.processAppDefault._unsafe_rec | Lean.Meta.Sym.Pattern | Lean.Expr → Lean.Expr → Lean.Meta.Sym.UnifyM✝ Bool | null | false |
Diffeomorph.prodAssoc._proof_1 | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_2} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {H : Type u_5}
[inst_5 : TopologicalSpace H] {G : Type u_4} [inst_6 : TopologicalSpace G] {G' : Type u_6}
[ins... | null | false |
Lean.ImportArtifacts.casesOn | Lean.Setup | {motive : Lean.ImportArtifacts → Sort u} →
(t : Lean.ImportArtifacts) → ((toArray : Array System.FilePath) → motive { toArray := toArray }) → motive t | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderInput.mk.inj | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | ∀ {α : Type} {inst : Hashable α} {inst_1 : DecidableEq α} {aig : Std.Sat.AIG α}
{lhs rhs cin lhs_1 rhs_1 cin_1 : aig.Ref},
{ lhs := lhs, rhs := rhs, cin := cin } = { lhs := lhs_1, rhs := rhs_1, cin := cin_1 } →
lhs = lhs_1 ∧ rhs = rhs_1 ∧ cin = cin_1 | null | true |
LipschitzWith.edist_lt_top | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β},
LipschitzWith K f → ∀ {x y : α}, edist x y ≠ ⊤ → edist (f x) (f y) < ⊤ | null | true |
SimpleGraph.Subgraph.coe._proof_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (G' : G.Subgraph), Std.Symm (Function.onFun G'.Adj Subtype.val) | null | false |
CategoryTheory.ProjectiveResolution.noConfusion | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.Limits.HasZeroObject C} →
{inst_2 : CategoryTheory.Limits.HasZeroMorphisms C} →
{Z : C} →
{t : CategoryTheory.ProjectiveResolution Z} →
{C' : Type u} →
... | null | false |
Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.zeroThm? | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Lean.Meta.Grind.Arith.Cutsat.ToIntInfo → Option (Option Lean.Expr) | null | true |
_private.Mathlib.Data.PFun.0.PFun.fix.match_1.eq_2 | Mathlib.Data.PFun | ∀ {α : Type u_2} {β : Type u_1} (motive : β ⊕ α → Sort u_3) (a' : α)
(h_1 : (b : β) → Sum.inr a' = Sum.inl b → motive (Sum.inl b))
(h_2 : (a'_1 : α) → Sum.inr a' = Sum.inr a'_1 → motive (Sum.inr a'_1)),
(match e : Sum.inr a' with
| Sum.inl b => h_1 b e
| Sum.inr a'_1 => h_2 a'_1 e) =
h_2 a' ⋯ | null | true |
_private.Mathlib.FieldTheory.KummerExtension.0.isSplittingField_X_pow_sub_C_of_root_adjoin_eq_top.match_1_1 | Mathlib.FieldTheory.KummerExtension | ∀ {K : Type u_1} [inst : Field K] {L : Type u_2} [inst_1 : Field L] [inst_2 : Algebra K L]
(motive : (primitiveRoots (Module.finrank K L) K).Nonempty → Prop)
(hK : (primitiveRoots (Module.finrank K L) K).Nonempty),
(∀ (w : K) (hζ : w ∈ primitiveRoots (Module.finrank K L) K), motive ⋯) → motive hK | null | false |
CategoryTheory.MonoidalClosed.uncurry_pre_app_assoc | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {A B : C} (X : C)
{Y : C} [inst_2 : CategoryTheory.Closed A] [inst_3 : CategoryTheory.Closed B] (f : Y ⟶ A ⟹ X) (g : B ⟶ A) {Z : C}
(h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCl... | null | true |
WeierstrassCurve.Affine.Point.toProjective | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | {R : Type r} →
[inst : CommRing R] →
[Nontrivial R] → {W : WeierstrassCurve.Affine R} → W.Point → (WeierstrassCurve.toProjective W).Point | An abbreviation for `WeierstrassCurve.Projective.Point.fromAffine` for dot notation. | true |
List.erase_eq_eraseTR | Init.Data.List.Impl | @List.erase = @List.eraseTR | null | true |
RestrictedProduct.homeoBot._proof_1 | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι : Type u_1} {R : ι → Type u_2} {A : (i : ι) → Set (R i)},
Function.LeftInverse (fun f i => f i) fun f => ⟨fun i => f i, ⋯⟩ | null | false |
Algebra.intTraceAux._proof_4 | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | ∀ (A : Type u_3) (K : Type u_2) (L : Type u_1) [inst : CommRing A] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra A K] [inst_4 : Algebra K L] [inst_5 : Algebra A L] [IsScalarTower A K L],
LinearMap.CompatibleSMul L K A K | null | false |
IsScalarTower.invertibleAlgebraCoeNat._proof_1 | Mathlib.RingTheory.AlgebraTower | ∀ (R : Type u_2) (A : Type u_1) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (n : ℕ)
(this : Invertible ((algebraMap ℕ R) n)), (↑↑(algebraMap R A)).1 ⅟((algebraMap ℕ R) n) * ↑n = 1 | null | false |
_private.Mathlib.Analysis.SpecificLimits.FloorPow.0.sum_div_pow_sq_le_div_sq._simp_1_9 | Mathlib.Analysis.SpecificLimits.FloorPow | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
WittVector.instAddCommGroupStandardOneDimIsocrystal._proof_11 | Mathlib.RingTheory.WittVector.Isocrystal | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (k : Type u_1) [inst_1 : CommRing k] (_m : ℤ),
autoParam
(∀ (n : ℕ) (x : WittVector.StandardOneDimIsocrystal p k _m),
WittVector.instAddCommGroupStandardOneDimIsocrystal._aux_8 p k _m (n + 1) x =
WittVector.instAddCommGroupStandardOneDimIsocrystal._aux_8 p k _m ... | null | false |
Lean.Grind.instCommRingInt64._proof_3 | Init.GrindInstances.Ring.SInt | ∀ (i : ℤ) (x : Int64), -i • x = -(i • x) | null | false |
CategoryTheory.Limits.isColimitCoconeOfHasColimitCurryCompColim._proof_2 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_5} {K : Type u_6} [inst : CategoryTheory.Category.{u_3, u_5} J]
[inst_1 : CategoryTheory.Category.{u_4, u_6} K] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} C]
(G : CategoryTheory.Functor (J × K) C) [inst_3 : CategoryTheory.Limits.HasColimitsOfShape K C]
[inst_4 : CategoryTheory.Limit... | null | false |
ComplexShape.rel_π₁ | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ {I₁ : Type u_1} {I₂ : Type u_2} {I₁₂ : Type u_4} {c₁ : ComplexShape I₁} (c₂ : ComplexShape I₂)
(c₁₂ : ComplexShape I₁₂) [inst : TotalComplexShape c₁ c₂ c₁₂] {i₁ i₁' : I₁},
c₁.Rel i₁ i₁' → ∀ (i₂ : I₂), c₁₂.Rel (c₁.π c₂ c₁₂ (i₁, i₂)) (c₁.π c₂ c₁₂ (i₁', i₂)) | null | true |
IsMulFreimanHom.inv | Mathlib.Combinatorics.Additive.FreimanHom | ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoid α] [inst_1 : DivisionCommMonoid β] {A : Set α} {B : Set β}
{f : α → β} {n : ℕ}, IsMulFreimanHom n A B f → IsMulFreimanHom n A B⁻¹ f⁻¹ | null | true |
_private.Mathlib.Algebra.Polynomial.Expand.0.Polynomial.contract_mul_expand._simp_1_2 | Mathlib.Algebra.Polynomial.Expand | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | null | false |
_private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.lt_omega0._simp_1_2 | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {c : Cardinal.{u_1}} {o : Ordinal.{u_1}}, (o < c.ord) = (o.card < c) | null | false |
Submonoid.coe_pos | Mathlib.Algebra.Order.GroupWithZero.Submonoid | ∀ (α : Type u_1) [inst : MulZeroOneClass α] [inst_1 : PartialOrder α] [inst_2 : PosMulStrictMono α]
[inst_3 : ZeroLEOneClass α] [inst_4 : NeZero 1], ↑(Submonoid.pos α) = Set.Ioi 0 | null | true |
Aesop.UnorderedArraySet.empty | Aesop.Util.UnorderedArraySet | {α : Type u_1} → [inst : BEq α] → Aesop.UnorderedArraySet α | O(1) | true |
_private.Init.Data.Format.Basic.0.Std.Format.SpaceResult.recOn | Init.Data.Format.Basic | {motive : Std.Format.SpaceResult✝ → Sort u} →
(t : Std.Format.SpaceResult✝) →
((foundLine foundFlattenedHardLine : Bool) →
(space : ℕ) →
motive { foundLine := foundLine, foundFlattenedHardLine := foundFlattenedHardLine, space := space }) →
motive t | null | false |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.visitNamespace._sunfold | Lean.Elab.DeclNameGen | Lean.Name → Lean.Elab.Command.NameGen.MkNameM✝ Unit | null | false |
CategoryTheory.SimplicialObject.Split.evalN | Mathlib.AlgebraicTopology.SimplicialObject.Split | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] → ℕ → CategoryTheory.Functor (CategoryTheory.SimplicialObject.Split C) C | The functor `SimplicialObject.Split C ⥤ C` which sends a simplicial object equipped
with a splitting to its nondegenerate `n`-simplices. | true |
CategoryTheory.Endofunctor.Coalgebra.functorOfNatTrans_map_f | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C C} (α : F ⟶ G)
{X Y : CategoryTheory.Endofunctor.Coalgebra F} (f : X ⟶ Y),
((CategoryTheory.Endofunctor.Coalgebra.functorOfNatTrans α).map f).f = f.f | null | true |
CategoryTheory.Limits.PreservesColimit.rec | Mathlib.CategoryTheory.Limits.Preserves.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
... | null | false |
Std.Iter.foldl_toList._cbv_eval_1 | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type w} {γ : Type x} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id]
[inst_2 : Std.IteratorLoop α Id Id] [Std.LawfulIteratorLoop α Id Id] {f : γ → β → γ} {init : γ} {it : Std.Iter β},
Std.Iter.fold f init it = List.foldl f init it.toList | null | false |
CommRingCat.Colimits.Prequotient._sizeOf_inst | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
{inst : CategoryTheory.SmallCategory J} →
(F : CategoryTheory.Functor J CommRingCat) → [SizeOf J] → SizeOf (CommRingCat.Colimits.Prequotient F) | null | false |
Lean.Elab.Tactic.SimpKind.casesOn | Lean.Elab.Tactic.Simp | {motive : Lean.Elab.Tactic.SimpKind → Sort u} →
(t : Lean.Elab.Tactic.SimpKind) →
motive Lean.Elab.Tactic.SimpKind.simp →
motive Lean.Elab.Tactic.SimpKind.simpAll → motive Lean.Elab.Tactic.SimpKind.dsimp → motive t | null | false |
Nat.Primrec | Mathlib.Computability.Primrec.Basic | (ℕ → ℕ) → Prop | The primitive recursive functions `ℕ → ℕ`. | true |
ConvexOn.secant_mono_aux1 | Mathlib.Analysis.Convex.Slope | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {s : Set 𝕜} {f : 𝕜 → 𝕜},
ConvexOn 𝕜 s f → ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (z - x) * f y ≤ (z - y) * f x + (y - x) * f z | null | true |
MvPolynomial.evalᵢ.eq_1 | Mathlib.FieldTheory.Finite.Polynomial | ∀ (σ K : Type u) [inst : Fintype K] [inst_1 : CommRing K],
MvPolynomial.evalᵢ σ K = MvPolynomial.evalₗ K σ ∘ₗ (MvPolynomial.restrictDegree σ K (Fintype.card K - 1)).subtype | null | true |
_private.Mathlib.Topology.MetricSpace.Thickening.0.Metric.eventually_notMem_thickening_of_infEDist_pos._simp_1_2 | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
Function.Embedding.refl_trans | Mathlib.Logic.Embedding.Basic | ∀ {α : Type u_1} {β : Type u_2} (f : α ↪ β), (Function.Embedding.refl α).trans f = f | null | true |
Matrix.diagonal_tsum | Mathlib.Topology.Instances.Matrix | ∀ {X : Type u_1} {n : Type u_5} {R : Type u_8} [inst : AddCommMonoid R] [inst_1 : TopologicalSpace R]
{L : SummationFilter X} [inst_2 : DecidableEq n] [T2Space R] {f : X → n → R},
Matrix.diagonal (∑'[L] (x : X), f x) = ∑'[L] (x : X), Matrix.diagonal (f x) | null | true |
PresheafOfModules.surjective_of_epi | Mathlib.Algebra.Category.ModuleCat.Presheaf.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (f : M₁ ⟶ M₂) [CategoryTheory.Epi f] (X : Cᵒᵖ),
Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom (f.app X)) | null | true |
Array.getElem_insertIdx_of_lt | Init.Data.Array.InsertIdx | ∀ {α : Type u} {xs : Array α} {x : α} {i k : ℕ} (w : i ≤ xs.size) (h : k < i), (xs.insertIdx i x w)[k] = xs[k] | null | true |
Lean.Parser.ParserExtension.instInhabitedEntry.default | Lean.Parser.Extension | Lean.Parser.ParserExtension.Entry | null | true |
OrderIso.isLUB_preimage._simp_1 | Mathlib.Order.Bounds.OrderIso | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α ≃o β) {s : Set β} {x : α},
IsLUB (⇑f ⁻¹' s) x = IsLUB s (f x) | null | false |
le_bot_iff._simp_1 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a ≤ ⊥) = (a = ⊥) | null | false |
Lean.Meta.Grind.Arith.Cutsat.Search.State.recOn | Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM | {motive : Lean.Meta.Grind.Arith.Cutsat.Search.State → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.Search.State) →
((cases : Lean.PArray Lean.Meta.Grind.Arith.Cutsat.Case) →
(precise : Bool) →
(decVars : Lean.FVarIdSet) → motive { cases := cases, precise := precise, decVars := decVars }) →
... | null | false |
_private.Init.Data.String.Defs.0.String.append_left_inj._simp_1_1 | Init.Data.String.Defs | ∀ {s t : String}, (s = t) = (s.toByteArray = t.toByteArray) | null | false |
Lean.Elab.Term.Do.homogenize | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.CodeBlock →
Lean.Elab.Term.Do.CodeBlock → Lean.Elab.TermElabM (Lean.Elab.Term.Do.CodeBlock × Lean.Elab.Term.Do.CodeBlock) | Given two code blocks `c₁` and `c₂`, make sure they have the same set of updated variables.
Let `ws` the union of the updated variables in `c₁‵ and ‵c₂`.
We use `extendUpdatedVars c₁ ws` and `extendUpdatedVars c₂ ws`
| true |
Std.DHashMap.Raw.mem_of_mem_filterMap | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {γ : α → Type w} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β}
[EquivBEq α] [LawfulHashable α] {f : (a : α) → β a → Option (γ a)} {k : α},
m.WF → k ∈ Std.DHashMap.Raw.filterMap f m → k ∈ m | null | true |
iInf_lt_top._simp_1 | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {s : ι → α}, (⨅ i, s i < ⊤) = ∃ i, s i < ⊤ | null | false |
CategoryTheory.Limits.pushout_inl_inv_inr_of_right_isIso_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
[inst_1 : CategoryTheory.IsIso f] {Z_1 : C} (h : Z ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inl f g)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.inv (CategoryTheory.Limits.push... | null | true |
SSet.oneTruncation₂._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ {X Y Z : SSet.Truncated 2} (f : X ⟶ Y) (g : Y ⟶ Z),
SSet.OneTruncation₂.map (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (SSet.OneTruncation₂.map f) (SSet.OneTruncation₂.map g) | null | false |
CategoryTheory.curriedYonedaLemma._proof_3 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_1} [inst : CategoryTheory.SmallCategory C] {X Y : Cᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.yoneda.op.comp CategoryTheory.coyoneda).map f)
(CategoryTheory.NatIso.ofComponents (fun x => CategoryTheory.yonedaEquiv.toIso) ⋯).hom =
CategoryTheory.CategoryStruct.comp
... | null | false |
Lean.Widget.instRpcEncodableInteractiveGoal.enc._@.Lean.Widget.InteractiveGoal.3114798910._hygCtx._hyg.1 | Lean.Widget.InteractiveGoal | Lean.Widget.InteractiveGoal → StateM Lean.Server.RpcObjectStore Lean.Json | null | false |
lp.instModulePreLp._proof_5 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {𝕜 : Type u_3} {α : Type u_1} {E : α → Type u_2} [inst : (i : α) → NormedAddCommGroup (E i)] [inst_1 : NormedRing 𝕜]
[inst_2 : (i : α) → Module 𝕜 (E i)] (a : 𝕜), a • 0 = 0 | null | false |
MulHomClass | Mathlib.Algebra.Group.Hom.Defs | (F : Type u_10) → (M : outParam (Type u_11)) → (N : outParam (Type u_12)) → [Mul M] → [Mul N] → [FunLike F M N] → Prop | `MulHomClass F M N` states that `F` is a type of multiplication-preserving homomorphisms.
You should declare an instance of this typeclass when you extend `MulHom`.
| true |
Homeomorph.compStarAlgEquiv'._proof_10 | Mathlib.Topology.ContinuousMap.Star | ∀ {X : Type u_3} {Y : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (𝕜 : Type u_4)
[inst_2 : CommSemiring 𝕜] (A : Type u_2) [inst_3 : TopologicalSpace A] [inst_4 : Semiring A]
[inst_5 : IsTopologicalSemiring A] [inst_6 : StarRing A] [inst_7 : ContinuousStar A] [inst_8 : Algebra 𝕜 A]
(f : ... | null | false |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.AbsolutelyContinuousFun.0.exists_dist_slope_lt_pairwiseDisjoint_hasSum._proof_1_12 | Mathlib.MeasureTheory.Integral.IntervalIntegral.AbsolutelyContinuousFun | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {f f' : ℝ → F} {d b : ℝ} (u : Set (ℝ × ℝ))
(x : ℝ),
(x ∈ Set.Ioo d b → HasDerivAt f (f' x) x) →
x ∉ {x | x ∈ Set.Ioo d b ∧ HasDerivAt f (f' x) x} \ ⋃ z ∈ u, Set.Icc z.1 z.2 →
x ∉ Set.Ioo d b \ ⋃ z ∈ u, Set.Icc z.1 z.2 | null | false |
instReprBinaryTree.repr._sunfold | Mathlib.Data.Tree.Basic | {α : Type u_1} → [Repr α] → BinaryTree α → ℕ → Std.Format | null | false |
Lean.Grind.CommRing.Poly.pow.match_1 | Init.Grind.Ring.CommSolver | (motive : ℕ → Sort u_1) → (k : ℕ) → (Unit → motive 0) → (Unit → motive 1) → ((k : ℕ) → motive k.succ) → motive k | null | false |
Lean.Elab.Tactic.evalIntro | Lean.Elab.Tactic.BuiltinTactic | Lean.Elab.Tactic.Tactic | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.