name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.Data.Lsp.Basic.0.Lean.Lsp.instHashableMarkupContent.hash.match_1 | Lean.Data.Lsp.Basic | (motive : Lean.Lsp.MarkupContent → Sort u_1) →
(x : Lean.Lsp.MarkupContent) →
((a : Lean.Lsp.MarkupKind) → (a_1 : String) → motive { kind := a, value := a_1 }) → motive x | false |
CommMonCat.instConcreteCategoryMonoidHomCarrier._proof_2 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y : CommMonCat} (f : X ⟶ Y), { hom' := f.hom' } = f | false |
MeasureTheory.MeasurePreserving.lintegral_comp | Mathlib.MeasureTheory.Integral.Lebesgue.Map | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} {g : α → β},
MeasureTheory.MeasurePreserving g μ ν →
∀ {f : β → ENNReal}, Measurable f → ∫⁻ (a : α), f (g a) ∂μ = ∫⁻ (b : β), f b ∂ν | true |
instBooleanAlgebraAsBoolAlg | Mathlib.Algebra.Ring.BooleanRing | {α : Type u_1} → [BooleanRing α] → BooleanAlgebra (AsBoolAlg α) | true |
Vector.instLT | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → [LT α] → LT (Vector α n) | true |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities.0.MvPolynomial.NewtonIdentities.mem_pairs._simp_1 | Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities | ∀ (σ : Type u_1) [inst : DecidableEq σ] [inst_1 : Fintype σ] (k : ℕ) (t : Finset σ × σ),
(t ∈ MvPolynomial.NewtonIdentities.pairs✝ σ k) = (t.1.card ≤ k ∧ (t.1.card = k → t.2 ∈ t.1)) | false |
_private.Lean.Meta.AppBuilder.0.Lean.Meta.mkBinaryRel | Lean.Meta.AppBuilder | Lean.Name → Lean.Name → Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | true |
Int.isPosValue._regBuiltin.Int.isPosValue.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.540685920._hygCtx._hyg.18 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit | false |
USize.ofBitVec_xor | Init.Data.UInt.Bitwise | ∀ (a b : BitVec System.Platform.numBits), { toBitVec := a ^^^ b } = { toBitVec := a } ^^^ { toBitVec := b } | true |
Std.Internal.UV.TCP.Socket | Std.Internal.UV.TCP | Type | true |
Isometry.preimage_ball | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
Isometry f → ∀ (x : α) (r : ℝ), f ⁻¹' Metric.ball (f x) r = Metric.ball x r | true |
Function.Surjective.smulWithZero | Mathlib.Algebra.GroupWithZero.Action.Defs | {M₀ : Type u_2} →
{A : Type u_7} →
{A' : Type u_8} →
[inst : Zero M₀] →
[inst_1 : Zero A] →
[inst_2 : SMulWithZero M₀ A] →
[inst_3 : Zero A'] →
[inst_4 : SMul M₀ A'] →
(f : ZeroHom A A') →
Function.Surjective ⇑f → (∀ (a : M₀) (b :... | true |
Std.Time.ZonedDateTime.minute | Std.Time.Zoned.ZonedDateTime | Std.Time.ZonedDateTime → Std.Time.Minute.Ordinal | true |
Orthonormal.isHilbertSum | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {ι : Type u_1} {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : CompleteSpace E] {v : ι → E} (hv : Orthonormal 𝕜 v),
⊤ ≤ (Submodule.span 𝕜 (Set.range v)).topologicalClosure →
IsHilbertSum 𝕜 (fun x => 𝕜) fun i => LinearIsometry.to... | true |
AlgebraicGeometry.StructureSheaf.toPushforwardStalk | Mathlib.AlgebraicGeometry.Spec | {R S : CommRingCat} →
(f : R ⟶ S) →
(p : PrimeSpectrum ↑R) →
S ⟶
((TopCat.Presheaf.pushforward CommRingCat (AlgebraicGeometry.Spec.topMap f)).obj
(AlgebraicGeometry.Spec.structureSheaf ↑S).obj).stalk
p | true |
Monoid.toMulAction | Mathlib.Algebra.Group.Action.Defs | (M : Type u_1) → [inst : Monoid M] → MulAction M M | true |
Aesop.GoalOrigin.recOn | Aesop.Tree.Data | {motive : Aesop.GoalOrigin → Sort u} →
(t : Aesop.GoalOrigin) →
motive Aesop.GoalOrigin.subgoal →
((«from» rep : Aesop.GoalId) → motive (Aesop.GoalOrigin.copied «from» rep)) →
motive Aesop.GoalOrigin.droppedMVar → motive t | false |
Bool.instBoundedOrder | Mathlib.Order.BoundedOrder.Basic | BoundedOrder Bool | true |
Polynomial.logMahlerMeasure_zero | Mathlib.Analysis.Polynomial.MahlerMeasure | Polynomial.logMahlerMeasure 0 = 0 | true |
CategoryTheory.ObjectProperty.strictLimitsClosureIter.congr_simp | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P P_1 : CategoryTheory.ObjectProperty C),
P = P_1 →
∀ {α : Type t} (J : α → Type u') [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)] {β : Type w'}
[inst_2 : LinearOrder β] [inst_3 : SuccOrder β] [inst_4 : WellFoundedLT β] (b b_1 : β),
... | true |
Algebra.Presentation.instCommRingCore._proof_18 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] {P : Algebra.Presentation R S ι σ} (a : P.Core), a * 0 = 0 | false |
Std.Internal.UV.System.instReprUnameInfo.repr | Std.Internal.UV.System | Std.Internal.UV.System.UnameInfo → ℕ → Std.Format | true |
Std.Roi.mk._flat_ctor | Init.Data.Range.Polymorphic.PRange | {α : Type u} → α → Std.Roi α | false |
Mathlib.StacksTag.Tag.ctorIdx | Mathlib.Tactic.StacksAttribute | Mathlib.StacksTag.Tag → ℕ | false |
Mathlib.Tactic.Algebraize.Config.properties | Mathlib.Tactic.Algebraize | Mathlib.Tactic.Algebraize.Config → Bool | true |
ProbabilityTheory.measurable_countablePartitionSet | Mathlib.Probability.Process.PartitionFiltration | ∀ (α : Type u_2) [inst : MeasurableSpace α] [inst_1 : MeasurableSpace.CountablyGenerated α] (n : ℕ),
Measurable (MeasurableSpace.countablePartitionSet n) | true |
Nat.instDecidablePredOdd | Mathlib.Algebra.Ring.Parity | DecidablePred Odd | true |
Submodule.rank_le_spanRank | Mathlib.Algebra.Module.SpanRank | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[StrongRankCondition R], Module.rank R M ≤ ⊤.spanRank | true |
Int16.not_eq_neg_sub | Init.Data.SInt.Bitwise | ∀ (a : Int16), ~~~a = -a - 1 | true |
CategoryTheory.Functor.ReflectsEffectiveEpis.mk._flat_ctor | Mathlib.CategoryTheory.EffectiveEpi.Preserves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {F : CategoryTheory.Functor C D},
(∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.EffectiveEpi (F.map f) → CategoryTheory.EffectiveEpi f) →
F.ReflectsEffectiveEpis | false |
Unitization.inr_add | Mathlib.Algebra.Algebra.Unitization | ∀ (R : Type u_3) {A : Type u_4} [inst : AddZeroClass R] [inst_1 : Add A] (m₁ m₂ : A), ↑(m₁ + m₂) = ↑m₁ + ↑m₂ | true |
ProbabilityTheory.Kernel.isRatCondKernelCDFAux_density_Iic | Mathlib.Probability.Kernel.Disintegration.StandardBorel | ∀ {α : Type u_1} {γ : Type u_3} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ}
[inst : MeasurableSpace.CountablyGenerated γ] (κ : ProbabilityTheory.Kernel α (γ × ℝ))
[ProbabilityTheory.IsFiniteKernel κ],
ProbabilityTheory.IsRatCondKernelCDFAux (fun p q => κ.density κ.fst p.1 p.2 (Set.Iic ↑q)) κ κ.fst | true |
_private.Mathlib.CategoryTheory.Functor.TypeValuedFlat.0.CategoryTheory.FunctorToTypes.fromOverFunctorElementsEquivalence._proof_14 | Mathlib.CategoryTheory.Functor.TypeValuedFlat | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (F : CategoryTheory.Functor C (Type u_1)) {X : C}
(x : F.obj X) (X_1 : CategoryTheory.Over (F.elementsMk X x)),
(CategoryTheory.FunctorToTypes.fromOverFunctor F x).map
(CategoryTheory.Over.homMk ↑(CategoryTheory.CategoryStruct.id X_1).left ⋯)
... | false |
_private.Init.Data.List.Lemmas.0.List.filter_sublist._simp_1_4 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l₁ l₂ : List α} (a : α), l₁.Sublist l₂ → l₁.Sublist (a :: l₂) = True | false |
SizeOf.mk.noConfusion | Init.SizeOf | {α : Sort u} →
{P : Sort u_1} → {sizeOf sizeOf' : α → ℕ} → { sizeOf := sizeOf } = { sizeOf := sizeOf' } → (sizeOf ≍ sizeOf' → P) → P | false |
Antitone.map_ciInf_of_continuousAt | Mathlib.Topology.Order.Monotone | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α]
[OrderTopology α] [inst_3 : ConditionallyCompleteLinearOrder β] [inst_4 : TopologicalSpace β] [OrderClosedTopology β]
{ι : Sort u_3} [Nonempty ι] {f : α → β} {g : ι → α},
ContinuousAt f (iInf g) →
Antiton... | true |
WType.NatαEquivPUnitSumPUnit.match_1 | Mathlib.Data.W.Constructions | (motive : PUnit.{u_1 + 1} ⊕ PUnit.{u_2 + 1} → Sort u_3) →
(b : PUnit.{u_1 + 1} ⊕ PUnit.{u_2 + 1}) →
((val : PUnit.{u_1 + 1}) → motive (Sum.inl val)) → ((val : PUnit.{u_2 + 1}) → motive (Sum.inr val)) → motive b | false |
Lean.Elab.ContextInfo.mk._flat_ctor | Lean.Elab.InfoTree.Types | Lean.Environment →
Option Lean.Environment →
Lean.FileMap →
Lean.MetavarContext →
Lean.Options →
Lean.Name →
List Lean.OpenDecl → Lean.NameGenerator → Option Lean.Name → Array Lean.Expr → Lean.Elab.ContextInfo | false |
_private.Mathlib.AlgebraicGeometry.StructureSheaf.0.AlgebraicGeometry.StructureSheaf.localizationtoStalkₗ._proof_4 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R M : Type u_1) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(x : ↑(AlgebraicGeometry.PrimeSpectrum.Top R)),
SMulCommClass R R ↑((AlgebraicGeometry.structurePresheafInModuleCat R M).stalk x) | false |
AddConstMap.coe_pow | Mathlib.Algebra.AddConstMap.Basic | ∀ {G : Type u_1} [inst : Add G] {a : G} (f : AddConstMap G G a a) (n : ℕ), ⇑(f ^ n) = (⇑f)^[n] | true |
Matrix.toLinOfInv._proof_3 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_3} [inst : CommSemiring R] {m : Type u_4} {n : Type u_5} [inst_1 : Fintype n] [inst_2 : DecidableEq n]
{M₁ : Type u_2} {M₂ : Type u_1} [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂] [inst_5 : Module R M₁]
[inst_6 : Module R M₂] (v₁ : Module.Basis n R M₁) (v₂ : Module.Basis m R M₂) [inst_7 : F... | false |
_private.Mathlib.Algebra.ContinuedFractions.Computation.Translations.0.GenContFract.IntFractPair.succ_nth_stream_eq_some_iff._simp_1_2 | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {x : Option α_1} {f : α_1 → Option α},
(x.bind f = some b) = ∃ a, x = some a ∧ f a = some b | false |
List.instAlternativeMonad_mathlib | Mathlib.Data.List.Monad | AlternativeMonad List | true |
Fact.mk._flat_ctor | Mathlib.Logic.Basic | ∀ {p : Prop}, p → Fact p | false |
LieSubalgebra.coe_set_eq | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(L₁' L₂' : LieSubalgebra R L), ↑L₁' = ↑L₂' ↔ L₁' = L₂' | true |
MvPolynomial.mem_homogeneousSubmodule | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] (n : ℕ) (p : MvPolynomial σ R),
p ∈ MvPolynomial.homogeneousSubmodule σ R n ↔ p.IsHomogeneous n | true |
instFullLightProfiniteLightCondSetLightProfiniteToLightCondSet | Mathlib.Condensed.Light.Functors | lightProfiniteToLightCondSet.Full | true |
_private.Mathlib.Topology.Bases.0.TopologicalSpace.IsTopologicalBasis.exists_nonempty_subset.match_1_1 | Mathlib.Topology.Bases | ∀ {α : Type u_1} {B : Set (Set α)} {u : Set α} (x : α) (motive : (∃ v ∈ B, x ∈ v ∧ v ⊆ u) → Prop)
(x_1 : ∃ v ∈ B, x ∈ v ∧ v ⊆ u), (∀ (v : Set α) (vB : v ∈ B) (xv : x ∈ v) (vu : v ⊆ u), motive ⋯) → motive x_1 | false |
CategoryTheory.Functor.leftOpId_inv_app | Mathlib.CategoryTheory.Opposites | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (X : Cᵒᵖᵒᵖ),
(CategoryTheory.Functor.leftOpId C).inv.app X = CategoryTheory.CategoryStruct.id (Opposite.unop (Opposite.unop X)) | true |
MeasureTheory.Measure.measure_isMulInvariant_eq_smul_of_isCompact_closure_of_innerRegularCompactLTTop | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [inst_2 : IsTopologicalGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [LocallyCompactSpace G] (μ' μ : MeasureTheory.Measure G)
[inst_6 : μ.IsHaarMeasure] [inst_7 : MeasureTheory.IsFiniteMeasureOnCompacts μ'] [inst_8 : μ'.IsMulLeftInvaria... | true |
CategoryTheory.ShortComplex.HomologyData.canonical_right_H | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasHomology],
(CategoryTheory.ShortComplex.HomologyData.canonical S).right.H = S.homology | true |
Lean.ConstantInfo.ctorInfo | Lean.Declaration | Lean.ConstructorVal → Lean.ConstantInfo | true |
_private.Mathlib.Topology.CWComplex.Classical.Subcomplex.0.Topology.RelCWComplex.Subcomplex.instRelCWComplex._simp_6 | Mathlib.Topology.CWComplex.Classical.Subcomplex | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Finset β} {hf : Set.InjOn f (f ⁻¹' ↑s)} {x : α},
(x ∈ s.preimage f hf) = (f x ∈ s) | false |
Int8.reduceGE._regBuiltin.Int8.reduceGE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3529513953._hygCtx._hyg.234 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | false |
Std.HashSet.Raw.Equiv.get!_eq | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [EquivBEq α] [LawfulHashable α]
[inst_4 : Inhabited α] {k : α}, m₁.WF → m₂.WF → m₁.Equiv m₂ → m₁.get! k = m₂.get! k | true |
ArithmeticFunction.instSemiring | Mathlib.NumberTheory.ArithmeticFunction.Defs | {R : Type u_1} → [inst : Semiring R] → Semiring (ArithmeticFunction R) | true |
Std.Internal.List.getEntry? | Std.Data.Internal.List.Associative | {α : Type u} → {β : α → Type v} → [BEq α] → α → List ((a : α) × β a) → Option ((a : α) × β a) | true |
_private.Mathlib.Topology.Compactness.CountablyCompact.0.isCountablyCompact_iff_infinite_subset_has_accPt._simp_1_3 | Mathlib.Topology.Compactness.CountablyCompact | ∀ {X : Type u} [inst : TopologicalSpace X] {α : Type u_1} {F : Filter α} {u : α → X} {x : X},
MapClusterPt x F u = ∀ s ∈ nhds x, ∃ᶠ (a : α) in F, u a ∈ s | false |
Batteries.AssocList.toList.eq_1 | Batteries.Data.AssocList | ∀ {α : Type u_1} {β : Type u_2}, Batteries.AssocList.nil.toList = [] | true |
CategoryTheory.Limits.ColimitPresentation.Total.Hom.mk.congr_simp | Mathlib.CategoryTheory.Presentable.ColimitPresentation | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u_1} {I : J → Type u_2}
[inst_1 : CategoryTheory.Category.{v_1, u_1} J] [inst_2 : (j : J) → CategoryTheory.Category.{u_3, u_2} (I j)]
{D : CategoryTheory.Functor J C} {P : (j : J) → CategoryTheory.Limits.ColimitPresentation (I j) (D.obj j)}
{k l :... | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.SynthInstance.MkTableKey.normLevel.match_1 | Lean.Meta.SynthInstance | (motive : Option Lean.Level → Sort u_1) →
(x : Option Lean.Level) → ((u' : Lean.Level) → motive (some u')) → (Unit → motive none) → motive x | false |
_private.Std.Data.DTreeMap.Internal.Queries.0.Std.DTreeMap.Internal.Impl.minEntry.match_1.splitter | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{β : α → Type u_2} →
(motive : (x : Std.DTreeMap.Internal.Impl α β) → x.isEmpty = false → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α β) →
(x_1 : x.isEmpty = false) →
((size : ℕ) →
(k : α) →
(v : β k) →
(r : Std.DTreeMap.In... | true |
CochainComplex.ShiftSequence.shiftIso.eq_1 | Mathlib.Algebra.Homology.HomotopyCategory.ShiftSequence | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.CategoryWithHomology C] (n a a' : ℤ) (ha' : n + a = a'),
CochainComplex.ShiftSequence.shiftIso C n a a' ha' =
(CategoryTheory.shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n)... | true |
_private.Mathlib.Algebra.Order.Floor.Ring.0.Int.preimage_Ico._simp_1_2 | Mathlib.Algebra.Order.Floor.Ring | ∀ {α : Type u_2} [inst : Ring α] [inst_1 : LinearOrder α] [inst_2 : FloorRing α] {z : ℤ} {a : α}, (z < ⌈a⌉) = (↑z < a) | false |
_private.Lean.Meta.Tactic.Repeat.0.Lean.Meta.repeat'Core.go.match_3.splitter | Lean.Meta.Tactic.Repeat | (motive : ℕ → Sort u_1) → (n : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive n | true |
_private.Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol.0.fastJacobiSymAux._unary._proof_1 | Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | ∀ a > 0, a % 4 = 0 → 0 < a / 4 | false |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable.0.isBigO_at_im_infty_jacobiTheta_sub_one._simp_1_2 | Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ b ≥ a, p b | false |
Equiv.optionIsSomeEquiv._proof_5 | Mathlib.Logic.Equiv.Option | ∀ (α : Type u_1) (x : α), (↑⟨some x, ⋯⟩).isSome = true | false |
DirectLimit.instCommMonoidWithZeroOfMonoidWithZeroHomClass._proof_5 | 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 : (... | false |
Tropical.instGroupTropical._proof_6 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : AddGroup R] (x : Tropical R), x⁻¹ * x = 1 | false |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithTerminal.widePullbackShapeEquivObj.match_1 | Mathlib.CategoryTheory.WithTerminal.Basic | {J : Type u_1} →
(motive : CategoryTheory.Limits.WidePullbackShape J → Sort u_2) →
(x : CategoryTheory.Limits.WidePullbackShape J) → ((x : J) → motive (some x)) → (Unit → motive none) → motive x | false |
Array.map_attach_eq_pmap | Init.Data.Array.Attach | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : { x // x ∈ xs } → β},
Array.map f xs.attach = Array.pmap (fun a h => f ⟨a, h⟩) xs ⋯ | true |
CategoryTheory.Under.id_right | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X : T} (U : CategoryTheory.Under X),
(CategoryTheory.CategoryStruct.id U).right = CategoryTheory.CategoryStruct.id U.right | true |
Lean.Lsp.LocationLink.mk.sizeOf_spec | Lean.Data.Lsp.Basic | ∀ (originSelectionRange? : Option Lean.Lsp.Range) (targetUri : Lean.Lsp.DocumentUri)
(targetRange targetSelectionRange : Lean.Lsp.Range),
sizeOf
{ originSelectionRange? := originSelectionRange?, targetUri := targetUri, targetRange := targetRange,
targetSelectionRange := targetSelectionRange } =
1 ... | true |
mem_skewAdjointMatricesLieSubalgebra_unit_smul | Mathlib.Algebra.Lie.SkewAdjoint | ∀ {R : Type u} {n : Type w} [inst : CommRing R] [inst_1 : DecidableEq n] [inst_2 : Fintype n] (u : Rˣ)
(J A : Matrix n n R), A ∈ skewAdjointMatricesLieSubalgebra (u • J) ↔ A ∈ skewAdjointMatricesLieSubalgebra J | true |
Batteries.Linter.UnnecessarySeqFocus.M | Batteries.Linter.UnnecessarySeqFocus | Type → Type → Type | true |
Bundle.mdifferentiableAt_zeroSection | Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable | ∀ (𝕜 : Type u_1) {B : Type u_2} {F : Type u_4} (E : B → Type u_6) [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace 𝕜 F] [inst_3 : TopologicalSpace (Bundle.TotalSpace F E)]
[inst_4 : (x : B) → TopologicalSpace (E x)] {EB : Type u_7} [inst_5 : NormedAddCommGroup EB]
[inst_... | true |
IsLocalization.moduleLid._proof_2 | Mathlib.RingTheory.Localization.BaseChange | ∀ {R : Type u_1} [inst : CommSemiring R] (A : Type u_2) [inst_1 : CommSemiring A] [inst_2 : Algebra R A],
SMulCommClass R A A | false |
_private.Mathlib.LinearAlgebra.LinearIndependent.Lemmas.0.LinearMap.iSupIndep_map._simp_1_1 | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b ≤ ⊥) | false |
CochainComplex.IsKInjective.mk._flat_ctor | Mathlib.Algebra.Homology.HomotopyCategory.KInjective | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{L : CochainComplex C ℤ},
(∀ {K : CochainComplex C ℤ} (f : K ⟶ L), HomologicalComplex.Acyclic K → Nonempty (Homotopy f 0)) → L.IsKInjective | false |
Lean.Compiler.LCNF.Simp.ConstantFold.FolderEntry.noConfusion | Lean.Compiler.LCNF.Simp.ConstantFold | {P : Sort u} →
{t t' : Lean.Compiler.LCNF.Simp.ConstantFold.FolderEntry} →
t = t' → Lean.Compiler.LCNF.Simp.ConstantFold.FolderEntry.noConfusionType P t t' | false |
Algebra.IsAlgebraic.isPurelyInseparable_of_isSepClosed | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Ring E] [IsDomain E] [inst_3 : Algebra F E]
[Algebra.IsAlgebraic F E] [IsSepClosed F], IsPurelyInseparable F E | true |
_private.Mathlib.CategoryTheory.NatIso.0.CategoryTheory.NatIso.ofComponents'._proof_4 | Mathlib.CategoryTheory.NatIso | ∀ {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] {F G : CategoryTheory.Functor C D} (app : (X : C) → F.obj X ≅ G.obj X)
(naturality :
∀ {X Y : C} (f : Y ⟶ X),
CategoryTheory.CategoryStruct.comp (app Y).inv (F.map f) =
Cat... | false |
AddSubmonoidClass.subtype.eq_1 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} {A : Type u_3} [inst : AddZeroClass M] [inst_1 : SetLike A M] [hA : AddSubmonoidClass A M] (S' : A),
AddSubmonoidClass.subtype S' = { toFun := Subtype.val, map_zero' := ⋯, map_add' := ⋯ } | true |
_private.Init.Data.Stream.0.Std.Stream.forIn.visit.match_1 | Init.Data.Stream | {β : Type u_1} →
(motive : ForInStep β → Sort u_2) →
(__do_lift : ForInStep β) →
((b : β) → motive (ForInStep.done b)) → ((b : β) → motive (ForInStep.yield b)) → motive __do_lift | false |
WeakBilin.instIsScalarTower | Mathlib.Topology.Algebra.Module.WeakBilin | ∀ {𝕜 : Type u_2} {𝕝 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : CommSemiring 𝕜] [inst_1 : CommSemiring 𝕝]
[inst_2 : AddCommMonoid E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommMonoid F] [inst_5 : Module 𝕜 F] [inst_6 : SMul 𝕝 𝕜]
[inst_7 : Module 𝕝 E] [s : IsScalarTower 𝕝 𝕜 E] (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜),... | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Option.getD.match_1.eq_1 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (x : α) (h_1 : (x : α) → motive (some x)) (h_2 : Unit → motive none),
(match some x with
| some x => h_1 x
| none => h_2 ()) =
h_1 x | true |
_private.Mathlib.RingTheory.Valuation.Discrete.Basic.0.Valuation.exists_isUniformizer_of_isCyclic_of_nontrivial._simp_1_3 | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {K : Type u} [inst : Field K] {Γ : Type u_1} [inst_1 : LinearOrderedCommGroupWithZero Γ] (v : Valuation K Γ) (x : K),
(x ∈ v.valuationSubring) = (v x ≤ 1) | false |
groupCohomology.H1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | {k G : Type u} → [inst : CommRing k] → [inst_1 : Group G] → Rep.{u, u, u} k G → ModuleCat k | true |
GCDMonoid.mk._flat_ctor | Mathlib.Algebra.GCDMonoid.Basic | {α : Type u_2} →
[inst : CommMonoidWithZero α] →
(∀ {a : α}, a ≠ 0 → IsLeftRegular a) →
(∀ {a : α}, a ≠ 0 → IsRightRegular a) →
(gcd lcm : α → α → α) →
(∀ (a b : α), gcd a b ∣ a) →
(∀ (a b : α), gcd a b ∣ b) →
(∀ {a b c : α}, a ∣ c → a ∣ b → a ∣ gcd c b) →
... | false |
_private.Mathlib.Data.Nat.Cast.Defs.0.two_add_two_eq_four._simp_1_1 | Mathlib.Data.Nat.Cast.Defs | ∀ {R : Type u_1} [inst : AddMonoidWithOne R], 2 = 1 + 1 | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_499 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α),
List.idxOfNth w [g (g a)] {g a, g (g a)}.card + 1 ≤ (List.filter (fun x => decide (x = w_1)) []).length →
List.idxOfNth w [g (g a)] {g a, g (g a)}.card < (List.findIdxs (fun x => decide (x = w_1)) []).length | false |
_private.Mathlib.GroupTheory.Perm.Fin.0.Fin.cycleIcc_of_le_of_le._proof_1_13 | Mathlib.GroupTheory.Perm.Fin | ∀ {n : ℕ} {i j k : Fin n}, i ≤ k → k ≤ j → ¬k = j → ↑k - ↑i < ↑j - ↑i | false |
AlgebraicGeometry.specializingMap_isZariskiLocalAtTarget | Mathlib.AlgebraicGeometry.Morphisms.UnderlyingMap | AlgebraicGeometry.IsZariskiLocalAtTarget (AlgebraicGeometry.topologically @SpecializingMap) | true |
Mathlib.Meta.FunProp.funPropDeclsExt | Mathlib.Tactic.FunProp.Decl | Mathlib.Meta.FunProp.FunPropDeclsExt | true |
IsCyclic.normalizer_le_centralizer | Mathlib.GroupTheory.Transfer | ∀ {G : Type u_3} [inst : Group G] [Finite G] {p : ℕ},
(Nat.card G).minFac = p → ∀ {P : Sylow p G}, IsCyclic ↥↑P → Subgroup.normalizer ↑↑P ≤ Subgroup.centralizer ↑P | true |
_private.Mathlib.Tactic.Linter.DeprecatedSyntaxLinter.0.Mathlib.Linter.Style.deprecatedSyntaxLinter.match_1 | Mathlib.Tactic.Linter.DeprecatedSyntaxLinter | (motive : Lean.SyntaxNodeKind → Sort u_1) →
(kind : Lean.SyntaxNodeKind) →
(Unit → motive `Lean.Parser.Tactic.refine') →
(Unit → motive `Mathlib.Tactic.cases') →
(Unit → motive `Mathlib.Tactic.induction') →
(Unit → motive `Lean.Parser.Tactic.tacticAdmit) →
(Unit → motive `Lean.... | false |
_private.Mathlib.Tactic.NormNum.Inv.0.Mathlib.Meta.NormNum.isNat_ratCast.match_1_1 | Mathlib.Tactic.NormNum.Inv | ∀ (motive : (x : ℚ) → (x_1 : ℕ) → Mathlib.Meta.NormNum.IsNat x x_1 → Prop) (x : ℚ) (x_1 : ℕ)
(x_2 : Mathlib.Meta.NormNum.IsNat x x_1), (∀ (n : ℕ), motive (↑n) n ⋯) → motive x x_1 x_2 | false |
LowerSet.prod_eq_bot._simp_1 | Mathlib.Order.UpperLower.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {s : LowerSet α} {t : LowerSet β},
(s ×ˢ t = ⊥) = (s = ⊥ ∨ t = ⊥) | false |
Mathlib.Meta.NormNum.Result.isNat._auto_1 | Mathlib.Tactic.NormNum.Result | Lean.Syntax | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.