name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.UInt32.reduceOfNatLT._regBuiltin.UInt32.reduceOfNatLT.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2393314560._hygCtx._hyg.346 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
_private.Mathlib.Topology.CWComplex.Classical.Basic.0.Topology.CWComplex.OfDiscreteClosed._simp_13 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
TensorProduct.tmul_add | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_5} {N : Type u_6} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (m : M) (n₁ n₂ : N),
m ⊗ₜ[R] (n₁ + n₂) = m ⊗ₜ[R] n₁ + m ⊗ₜ[R] n₂ | null | true |
CategoryTheory.piEquivalenceFunctorDiscreteCompEvaluationIso._proof_2 | Mathlib.CategoryTheory.Discrete.Basic | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} (j : J) {X Y : J → C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.piEquivalenceFunctorDiscrete J C).functor.comp
((CategoryTheory.evaluation (CategoryTheory.Discrete J) C).obj { as := j })).map
... | null | false |
Metric.unitBall.instSemigroupWithZero._proof_2 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : NonUnitalSeminormedRing 𝕜] (x : ↑(Metric.ball 0 1)), x * 0 = 0 | null | false |
CategoryTheory.Limits.BinaryFan.isLimitCompLeftIso.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryFan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y X' : C} (c : CategoryTheory.Limits.BinaryFan X Y)
(f : X ⟶ X') [inst_1 : CategoryTheory.IsIso f] (h : CategoryTheory.Limits.IsLimit c),
c.isLimitCompLeftIso f h =
CategoryTheory.Limits.BinaryFan.isLimitMk
(fun s =>
CategoryTheory.Limits... | null | true |
Lean.Elab.Command.statefulLintersRef | Lean.Elab.Command | IO.Ref (Array Lean.Elab.Command.StatefulLinterEntry) | null | true |
_private.Mathlib.Data.Int.CardIntervalMod.0.Int.Ico_filter_modEq_eq._simp_1_7 | Mathlib.Data.Int.CardIntervalMod | ∀ {n a b : ℤ}, (a ≡ b [ZMOD n]) = (n ∣ b - a) | null | false |
List.prefix_of_prefix_length_le | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ l₃ : List α}, l₁ <+: l₃ → l₂ <+: l₃ → l₁.length ≤ l₂.length → l₁ <+: l₂ | null | true |
HomotopicalAlgebra.ModelCategory.mk'._proof_3 | Mathlib.AlgebraicTopology.ModelCategory.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
[(HomotopicalAlgebra.weakEquivalences C).HasTwoOutOfThreeProperty],
(HomotopicalAlgebra.weakEquivalences C).HasTwoOutOfThreeProperty | null | false |
Lean.instToJsonModuleArtifacts.toJson | Lean.Setup | Lean.ModuleArtifacts → Lean.Json | null | true |
MvPolynomial.IsHomogeneous.totalDegree | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] {φ : MvPolynomial σ R} {n : ℕ},
φ.IsHomogeneous n → φ ≠ 0 → φ.totalDegree = n | null | true |
CircleDeg1Lift.iterate_le_of_map_le_add_int | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift) {x : ℝ} {m : ℤ}, f x ≤ x + ↑m → ∀ (n : ℕ), (⇑f)^[n] x ≤ x + ↑n * ↑m | null | true |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBSet.upperBoundP?_exists.match_1_4 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {t : RBTree.RBSet α cmp}
(motive : (∃ x ∈ ↑t, ¬cut x = Ordering.gt) → Prop) (x : ∃ x ∈ ↑t, ¬cut x = Ordering.gt),
(∀ (x : α) (h1 : x ∈ ↑t) (h2 : ¬cut x = Ordering.gt), motive ⋯) → motive x | null | false |
Padic.addValuation | Mathlib.NumberTheory.Padics.PadicNumbers | {p : ℕ} → [hp : Fact (Nat.Prime p)] → AddValuation ℚ_[p] (WithTop ℤ) | The additive `p`-adic valuation on `ℚ_[p]`, as an `addValuation`. | true |
Ideal.span_union | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Semiring α] (s t : Set α), Ideal.span (s ∪ t) = Ideal.span s ⊔ Ideal.span t | null | true |
Valuation.map_sub_eq_of_lt_left | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀)
{x y : R}, v y < v x → v (x - y) = v x | null | true |
Lean.Grind.Fin.eq_iff_val_eq | Init.Grind.Homo.Fin | ∀ {n : ℕ} (a b : Fin n), a = b ↔ ↑a = ↑b | null | true |
_private.Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology.0.IsValuativeTopology.instIsTopologicalAddGroup.match_1 | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ (R : Type u_1) [inst : Ring R] [inst_1 : ValuativeRel R] (γ : (↑(ValuativeRel.valuation R)).ValueGroup₀ˣ)
(motive :
(x : R × R) →
x ∈ {x | (ValuativeRel.valuation R).restrict x < ↑γ} ×ˢ {x | (ValuativeRel.valuation R).restrict x < ↑γ} → Prop)
(x : R × R)
(hx : x ∈ {x | (ValuativeRel.valuation R).restr... | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.parseQuarterShort | Std.Time.Format.Basic | Std.Time.DateFormatSymbols → Std.Internal.Parsec.String.Parser Std.Time.Month.Quarter | null | true |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.VarInfo._sizeOf_1 | Lean.Compiler.LCNF.ExplicitRC | Lean.Compiler.LCNF.VarInfo✝ → ℕ | null | false |
FirstOrder.Language.LHom.sumInl_onFunction | Mathlib.ModelTheory.LanguageMap | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} (_n : ℕ) (val : L.Functions _n),
FirstOrder.Language.LHom.sumInl.onFunction val = Sum.inl val | null | true |
_private.Init.Data.String.Decode.0.utf8DecodeChar?_eq_assemble₃._proof_2 | Init.Data.String.Decode | ∀ {b : ByteArray}, 3 ≤ b.size → ¬1 < b.size → False | null | false |
Subarray.start | Init.Data.Array.Subarray | {α : Type u_1} → Subarray α → ℕ | The starting index of the region of interest (inclusive). | true |
Std.ExtTreeSet.max_erase_le_max | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α}
{he : t.erase k ≠ ∅}, (cmp ((t.erase k).max he) (t.max ⋯)).isLE = true | null | true |
NormedRing.toNonUnitalNormedRing._proof_4 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [β : NormedRing α] (n : ℕ) (a : α), Int.negSucc n • a = -(↑n.succ • a) | null | false |
Set.Ico_add_Ioc_subset | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Add α] [inst_1 : PartialOrder α] [AddLeftStrictMono α] [AddRightStrictMono α] (a b c d : α),
Set.Ico a b + Set.Ioc c d ⊆ Set.Ioo (a + c) (b + d) | null | true |
AddUnits.opEquiv._proof_4 | Mathlib.Algebra.Group.Units.Opposite | ∀ {M : Type u_1} [inst : AddMonoid M] (u : AddUnits Mᵃᵒᵖ), AddOpposite.unop ↑(-u) + AddOpposite.unop ↑u = 0 | null | false |
CompletelyDistribLattice.MinimalAxioms | Mathlib.Order.CompleteBooleanAlgebra | (α : Type u) → [CompleteLattice α] → Prop | Structure containing the minimal axioms required to check that an order is a completely
distributive. Do NOT use, except for implementing `CompletelyDistribLattice` via
`CompletelyDistribLattice.ofMinimalAxioms`.
This structure omits the `himp`, `compl`, `sdiff`, `hnot` fields, which can be recovered using
`Completely... | true |
Equiv.toHomeomorph._proof_3 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ Y),
(∀ (s : Set Y), IsOpen (⇑e ⁻¹' s) ↔ IsOpen s) → Continuous e.invFun | null | false |
UpperHemicontinuousWithinAt.eq_1 | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : α → Set β) (s : Set α)
(x : α), UpperHemicontinuousWithinAt f s x = SemicontinuousWithinAt (fun x t => t ∈ nhdsSet (f x)) s x | null | true |
Submodule.smul_comap_le_comap_smul | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type w}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M') (S : Submodule R M') (I : Ideal R),
I • Submodule.comap f S ≤ Submodule.comap f (I • S) | null | true |
WeierstrassCurve.Affine.instDecidableEqPoint.decEq._proof_2 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type u_1} {inst : CommRing R} {W' : WeierstrassCurve.Affine R} (a a_1 : R) (a_2 : W'.Nonsingular a a_1),
a_2 = a_2 | null | false |
Finsupp.isCentralScalar | Mathlib.Data.Finsupp.SMulWithZero | ∀ (α : Type u_1) (M : Type u_2) {R : Type u_4} [inst : Zero M] [inst_1 : SMulZeroClass R M]
[inst_2 : SMulZeroClass Rᵐᵒᵖ M] [IsCentralScalar R M], IsCentralScalar R (α →₀ M) | null | true |
_private.Mathlib.Algebra.Order.Chebyshev.0.Finset.sum_mul_le_sum_mul_of_sum_range_le._simp_1_3 | Mathlib.Algebra.Order.Chebyshev | ∀ {α : Type u_9} [inst : Mul α] (a b : α), a * b = a • b | null | false |
Lean.Elab.Term.Arg.stx.noConfusion | Lean.Elab.Arg | {P : Sort u} →
{val val' : Lean.Syntax} → Lean.Elab.Term.Arg.stx val = Lean.Elab.Term.Arg.stx val' → (val = val' → P) → P | null | false |
mersenne_le_mersenne._gcongr_1 | Mathlib.NumberTheory.LucasLehmer | ∀ {p q : ℕ}, p ≤ q → mersenne p ≤ mersenne q | null | false |
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.IsReflection.conj._simp_1_1 | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {G : Type u_1} [inst : DivInvMonoid G] (x : G), x⁻¹ = x ^ (-1) | null | false |
instIsContMDiffRiemannianBundleOfNatWithTopENat_2 | Mathlib.Geometry.Manifold.VectorBundle.Riemannian | ∀ {EB : Type u_1} [inst : NormedAddCommGroup EB] [inst_1 : NormedSpace ℝ EB] {HB : Type u_2}
[inst_2 : TopologicalSpace HB] {IB : ModelWithCorners ℝ EB HB} {B : Type u_3} [inst_3 : TopologicalSpace B]
[inst_4 : ChartedSpace HB B] {F : Type u_4} [inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace ℝ F]
{E : B → T... | null | true |
Polynomial.card_roots_sub_C | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] {p : Polynomial R} {a : R},
0 < p.degree → ↑(p - Polynomial.C a).roots.card ≤ p.degree | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.containsKey_of_containsKey_filterMap._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} (p : α → Bool) (x : Option α), (Option.all p x = true) = ∀ (y : α), x = some y → p y = true | null | false |
CategoryTheory.BasedFunctor._sizeOf_inst | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | {𝒮 : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} 𝒮} →
(𝒳 : CategoryTheory.BasedCategory 𝒮) →
(𝒴 : CategoryTheory.BasedCategory 𝒮) → [SizeOf 𝒮] → SizeOf (CategoryTheory.BasedFunctor 𝒳 𝒴) | null | false |
MeasureTheory.measurable_inclusion_predictable | Mathlib.Probability.Process.Predictable | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : LinearOrder ι] [inst_1 : OrderBot ι]
[inst_2 : MeasurableSpace ι] [inst_3 : TopologicalSpace ι] [OpensMeasurableSpace ι] [OrderClosedTopology ι]
{𝓕 : MeasureTheory.Filtration ι m} {i : ι}, Measurable fun x => (↑x.1, x.2) | The inclusion map from [0,i] × Ω with the subtype × 𝓕 i σ-algebra) to ι × Ω with the
predictable σ-algebra is measurable | true |
RBTree.RBNode.Stream.ctorElim | Batteries.Recycling.RBTree.Basic | {α : Type u_1} →
{motive : RBTree.RBNode.Stream α → Sort u} →
(ctorIdx : ℕ) →
(t : RBTree.RBNode.Stream α) → ctorIdx = t.ctorIdx → RBTree.RBNode.Stream.ctorElimType ctorIdx → motive t | null | false |
_private.Batteries.Data.Nat.Bitwise.Lemmas.0.Nat.and_or_left_injective._simp_1_2 | Batteries.Data.Nat.Bitwise.Lemmas | ∀ (x y i : ℕ), (x.testBit i || y.testBit i) = (x ||| y).testBit i | null | false |
CategoryTheory.Square.rec | Mathlib.CategoryTheory.Square | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.Square C → Sort u_1} →
({X₁ X₂ X₃ X₄ : C} →
(f₁₂ : X₁ ⟶ X₂) →
(f₁₃ : X₁ ⟶ X₃) →
(f₂₄ : X₂ ⟶ X₄) →
(f₃₄ : X₃ ⟶ X₄) →
(fac : CategoryTheory.CategoryStruct.c... | null | false |
AList.insertRec._proof_1 | Mathlib.Data.List.AList | ∀ {α : Type u_1} {β : α → Type u_2}, WellFounded (invImage (fun x => x) sizeOfWFRel).1 | null | false |
Equiv.symm_image_subset._simp_1 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {β : Type u_4} (e : α ≃ β) (s : Set α) (t : Set β), (⇑e.symm '' t ⊆ s) = (t ⊆ ⇑e '' s) | null | false |
Padic.mulValuation._proof_1 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)], (if 0 = 0 then 0 else WithZero.exp (-Padic.valuation 0)) = 0 | null | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Rat.0.Std.Tactic.BVDecide.LRAT.Internal.State.checkRat.match_7.splitter | Std.Tactic.BVDecide.LRAT.Internal.Rat | (motive : Std.Tactic.BVDecide.LRAT.Internal.PropagateResult → Sort u_1) →
(x : Std.Tactic.BVDecide.LRAT.Internal.PropagateResult) →
(Unit → motive Std.Tactic.BVDecide.LRAT.Internal.PropagateResult.conflict) →
(Unit → motive Std.Tactic.BVDecide.LRAT.Internal.PropagateResult.error) →
((assign : Std.Ta... | null | true |
String.Slice.Pos.slice_lt_iff | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} {p : (s.slice p₀ p₁ h).Pos} {q : s.Pos} {h₀ : p₀ ≤ q} {h₁ : q ≤ p₁},
q.slice p₀ p₁ h₀ h₁ < p ↔ q < String.Slice.Pos.ofSlice p | null | true |
Quiver.SingleObj.listToPath_pathToList | Mathlib.Combinatorics.Quiver.SingleObj | ∀ {α : Type u_1} {x : Quiver.SingleObj α} (p : Quiver.Path (Quiver.SingleObj.star α) x),
Quiver.SingleObj.listToPath (Quiver.SingleObj.pathToList p) = Quiver.Path.cast ⋯ ⋯ p | null | true |
Ordinal.add_log_le_log_mul | Mathlib.SetTheory.Ordinal.Exponential | ∀ {x y : Ordinal.{u_1}} (b : Ordinal.{u_1}), x ≠ 0 → y ≠ 0 → Ordinal.log b x + Ordinal.log b y ≤ Ordinal.log b (x * y) | null | true |
SimpleGraph.incidenceSetEquivNeighborSet._proof_1 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u_1} (G : SimpleGraph V) (v : V) (e : ↑(G.incidenceSet v)), ↑e ∈ G.incidenceSet v | null | false |
HahnSeries.cardSupp_congr | Mathlib.RingTheory.HahnSeries.Cardinal | ∀ {Γ : Type u_1} {R : Type u_2} {S : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : Zero S]
{x : HahnSeries Γ R} {y : HahnSeries Γ S}, x.support = y.support → x.cardSupp = y.cardSupp | null | true |
_private.Lean.Util.Diff.0.Lean.Diff.matchSuffix._proof_2 | Lean.Util.Diff | ∀ {α : Type u_1} (left right : Subarray α) (i : ℕ),
i < Std.Slice.size left ∧ i < Std.Slice.size right → ¬Std.Slice.size right - i - 1 < Std.Slice.size right → False | null | false |
Std.HashSet.Equiv.diff_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ m₃ : Std.HashSet α} [EquivBEq α] [LawfulHashable α],
m₂.Equiv m₃ → (m₁ \ m₂).Equiv (m₁ \ m₃) | null | true |
Rep.hom_inv_rightUnitor | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} {G : Type v} [inst : CommRing k] [inst_1 : Monoid G] {X : Rep.{u, u, v} k G},
Rep.Hom.hom (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).inv = ↑(Representation.TensorProduct.rid k X.ρ).symm | null | true |
CategoryTheory.Bicategory.RetractArrow₁.map_commi | Mathlib.CategoryTheory.Bicategory.RetractArrow | ∀ {C : Type u} [inst : CategoryTheory.Bicategory C] {X Y X' Y' : C} {f' : X' ⟶ Y'} {f : X ⟶ Y}
(r : CategoryTheory.Bicategory.RetractArrow₁ f' f) {D : Type u_1} [inst_1 : CategoryTheory.Bicategory D]
(F : CategoryTheory.Pseudofunctor C D),
(r.map F).commi = (F.mapComp f' r.i₂).symm ≪≫ F.map₂Iso r.commi ≪≫ F.mapCo... | null | true |
ApplicativeTransformation.mk.inj | Mathlib.Control.Traversable.Basic | ∀ {F : Type u → Type v} {inst : Applicative F} {G : Type u → Type w} {inst_1 : Applicative G}
{app : (α : Type u) → F α → G α} {preserves_pure' : ∀ {α : Type u} (x : α), app α (pure x) = pure x}
{preserves_seq' : ∀ {α β : Type u} (x : F (α → β)) (y : F α), app β (x <*> y) = app (α → β) x <*> app α y}
{app_1 : (α ... | null | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_36 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {i : ℕ} (s : ℕ),
i < (List.filter p (head :: tail)).length → ¬p head = true → i < (List.filter p tail).length | null | false |
_private.Mathlib.Geometry.Manifold.IntegralCurve.Basic.0.IsMIntegralCurveAt.hasMFDerivAt.match_1_1 | Mathlib.Geometry.Manifold.IntegralCurve.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {γ : ℝ → M}
{v : (x : M) → TangentSpace I x} {t₀ : ℝ} (motive : (∃ s ∈ nhds t₀, IsMIntegralCurv... | null | false |
ContinuousLinearMap.rTensor_eq_mapL | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} (G : Type u_4) [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : InnerProductSpace 𝕜 G] (f : E →L[𝕜] F),
ContinuousLinear... | null | true |
Representation.apply_eq_of_coe_eq | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : Semiring k] [inst_1 : Group G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (S : Subgroup G)
[Representation.IsTrivial (MonoidHom.comp ρ S.subtype)] (g h : G), ↑g = ↑h → ρ g = ρ h | null | true |
String.Slice.Pos.prev?_eq_some_prev | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {p : s.Pos} (h : p ≠ s.startPos), p.prev? = some (p.prev h) | null | true |
Topology.RelCWComplex.iUnion_skeleton_eq_complex | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : T2Space X] [inst_1 : Topology.RelCWComplex C D],
⋃ n, ↑(Topology.RelCWComplex.skeleton C ↑n) = C | null | true |
Matrix.rank_mul_eq_left_of_isUnit_det | Mathlib.LinearAlgebra.Matrix.Rank | ∀ {m : Type um} {n : Type un} [inst : Fintype n] {R : Type u_1} [inst_1 : CommRing R] [inst_2 : DecidableEq n]
(A : Matrix n n R) (B : Matrix m n R), IsUnit A.det → (B * A).rank = B.rank | Right multiplying by an invertible matrix does not change the rank | true |
mvfderivWithin_neg | Mathlib.Geometry.Manifold.MFDeriv.NormedSpace | ∀ {𝕜 : 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] {F : Type u_8} [inst_6 : NormedAddCommG... | null | true |
_private.Mathlib.Topology.Algebra.Valued.NormedValued.0.Valued.toNormedField._simp_21 | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ (r₁ r₂ : NNReal), ↑r₁ * ↑r₂ = ↑(r₁ * r₂) | null | false |
RingHom.map_rat_algebraMap | Mathlib.Algebra.Algebra.Rat | ∀ {R : Type u_2} {S : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Algebra ℚ R] [inst_3 : Algebra ℚ S]
(f : R →+* S) (r : ℚ), f ((algebraMap ℚ R) r) = (algebraMap ℚ S) r | null | true |
DirectLimit.instDivisionRing._proof_18 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | false |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnModule.coeff_smul_right._simp_1_1 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
_private.Lean.Meta.MethodSpecs.0.Lean.getMethodSpecsInfo._sparseCasesOn_1 | Lean.Meta.MethodSpecs | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.LinearAlgebra.Transvection.Basic.0.LinearEquiv.dilatransvection._simp_1 | Mathlib.LinearAlgebra.Transvection.Basic | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
_private.Mathlib.GroupTheory.Perm.Support.0.Equiv.Perm.disjoint_swap_swap._proof_1_1 | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] {x y z t : α},
[x, y, z, t].Nodup → ∀ (x_1 : α), (Equiv.swap x y) x_1 = x_1 ∨ (Equiv.swap z t) x_1 = x_1 | null | false |
Nat.getElem!_toList_roo_eq_zero | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, n ≤ i + (m + 1) → (m<...n).toList[i]! = 0 | null | true |
LieIdeal.mem_comap._simp_1 | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] {f : L →ₗ⁅R⁆ L'} {J : LieIdeal R L'} {x : L},
(x ∈ LieIdeal.comap f J) = (f x ∈ J) | null | false |
PadicInt.zmodRepr_eq_zero_iff_dvd | Mathlib.NumberTheory.Padics.RingHoms | ∀ {p : ℕ} [hp_prime : Fact (Nat.Prime p)] {x : ℤ_[p]}, x.zmodRepr = 0 ↔ ↑p ∣ x | null | true |
Aesop.ScopeName.global | Aesop.Rule.Name | Aesop.ScopeName | null | true |
nnnormHom_apply | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] [inst_1 : NormOneClass α] [inst_2 : NormMulClass α] (x : α),
nnnormHom x = ‖x‖₊ | null | true |
Real.pow_div_factorial_le_exp | Mathlib.Analysis.Complex.Exponential | ∀ (x : ℝ), 0 ≤ x → ∀ (n : ℕ), x ^ n / ↑n.factorial ≤ Real.exp x | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Determinant.Basic.0.Matrix.det_fromBlocks_zero₂₁._simp_1_8 | Mathlib.LinearAlgebra.Matrix.Determinant.Basic | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
Lean.Elab.Tactic.ElimTargetView.ctorIdx | Lean.Elab.Tactic.Induction | Lean.Elab.Tactic.ElimTargetView → ℕ | null | false |
Bialgebra.toCoalgebra | Mathlib.RingTheory.Bialgebra.Basic | {R : Type u} → {A : Type v} → {inst : CommSemiring R} → {inst_1 : Semiring A} → [self : Bialgebra R A] → Coalgebra R A | null | true |
Finset.prod_inv_index | Mathlib.Algebra.Group.Pointwise.Finset.BigOperators | ∀ {α : Type u_1} {ι : Type u_2} [inst : CommMonoid α] [inst_1 : DecidableEq ι] [inst_2 : InvolutiveInv ι] (s : Finset ι)
(f : ι → α), ∏ i ∈ s⁻¹, f i = ∏ i ∈ s, f i⁻¹ | null | true |
Neg.rec | Init.Prelude | {α : Type u} → {motive : Neg α → Sort u_1} → ((neg : α → α) → motive { neg := neg }) → (t : Neg α) → motive t | null | false |
MeasureTheory.SimpleFunc.instCommRing._proof_7 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : CommRing β],
autoParam (∀ (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1)) AddGroupWithOne.intCast_negSucc._autoParam | null | false |
CategoryTheory.effectiveEpiFamilyStructOfComp._proof_3 | Mathlib.CategoryTheory.EffectiveEpi.Comp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I : Type u_3} {Z Y : I → C} {X : C}
(g : (i : I) → Z i ⟶ Y i) (f : (i : I) → Y i ⟶ X) {W : C} (φ : (a : I) → Y a ⟶ W) (m : X ⟶ W),
(∀ (a : I), CategoryTheory.CategoryStruct.comp (f a) m = φ a) →
∀ (i : I),
CategoryTheory.CategoryStruct.comp (... | null | false |
fderivWithin_finsetProd | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {ι : Type u_4} {𝔸' : Type u_6} [inst_3 : NormedCommRing 𝔸']
[inst_4 : NormedAlgebra 𝕜 𝔸'] {u : Finset ι} {g : ι → E → 𝔸'} [inst_5 : DecidableEq ι] {x : E},
UniqueDiffWi... | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastArithShiftRightConst.go_denote_eq._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight | ∀ {w : ℕ} (distance curr idx : ℕ), idx < w → w - 1 < w | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd.0.SSet.prodStdSimplex.weakRankFunction._proof_11 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} (k : Fin (m + 1)) (n d : ℕ)
(s :
(CategoryTheory.MonoidalCategoryStruct.tensorObj (SSet.stdSimplex.obj { len := m + 1 })
(SSet.stdSimplex.obj { len := n })).obj
(Opposite.op { len := d + 1 }))
(hs₁ :
s ∈
(CategoryTheory.MonoidalCategoryStruct.tensorObj (SSet.stdSimplex.obj { ... | null | false |
UInt16.reduceEq._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.3273093604._hygCtx._hyg.9 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.Meta.Simp.Simproc | null | false |
Lean.Meta.SynthInstance.Instance.ctorIdx | Lean.Meta.SynthInstance | Lean.Meta.SynthInstance.Instance → ℕ | null | false |
FreeMonoid.freeMonoidCongr_of | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_6} {β : Type u_7} (e : α ≃ β) (a : α),
(FreeMonoid.freeMonoidCongr e) (FreeMonoid.of a) = FreeMonoid.of (e a) | null | true |
Equiv.ofUnique._proof_2 | Mathlib.Logic.Equiv.Defs | ∀ (α : Sort u_2) (β : Sort u_1) [inst : Unique α] [inst_1 : Unique β] (x : β), default (default x) = x | null | false |
String.toList_map | Init.Data.String.Lemmas.Modify | ∀ {f : Char → Char} {s : String}, (String.map f s).toList = List.map f s.toList | null | true |
Finset.compl_eq_univ_iff._simp_1 | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (s : Finset α), (sᶜ = Finset.univ) = (s = ∅) | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.addZ_smul._simp_1_4 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] (P : Fin 3 → R) (u : R), (u • P) 2 = u * P 2 | null | false |
Lean.Attribute.Builtin.getPrio | Lean.Attributes | Lean.Syntax → Lean.AttrM ℕ | null | true |
Lean.Meta.CaseValuesSubgoal._sizeOf_inst | Lean.Meta.Match.CaseValues | SizeOf Lean.Meta.CaseValuesSubgoal | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.