name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Util.Delaborators.0.exists_delab.match_1 | Mathlib.Util.Delaborators | (motive : Option (Array (Lean.TSyntax `Lean.bracketedExplicitBinders)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `Lean.bracketedExplicitBinders))) →
((groups : Array (Lean.TSyntax `Lean.bracketedExplicitBinders)) → motive (some groups)) →
(Unit → motive none) → motive x | false |
UInt8.instOfNat | Init.Data.UInt.BasicAux | {n : ℕ} → OfNat UInt8 n | true |
ComplexShape.EulerCharSigns.noConfusion | Mathlib.Algebra.Homology.EulerCharacteristic | {P : Sort u} →
{ι : Type u_1} →
{c : ComplexShape ι} →
{t : c.EulerCharSigns} →
{ι' : Type u_1} →
{c' : ComplexShape ι'} →
{t' : c'.EulerCharSigns} → ι = ι' → c ≍ c' → t ≍ t' → ComplexShape.EulerCharSigns.noConfusionType P t t' | false |
Lean.Parser.Tactic.unknown._regBuiltin.Lean.Parser.Tactic.unknown.parenthesizer_11 | Lean.Parser.Tactic | IO Unit | false |
mdifferentiable_smul_const_section | Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable | ∀ {𝕜 : Type u_1} {B : Type u_2} {F : Type u_4} {E : B → Type u_6} [inst : TopologicalSpace B]
[inst_1 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_2 : (x : B) → TopologicalSpace (E x)]
[inst_3 : NormedAddCommGroup F] [inst_4 : NontriviallyNormedField 𝕜] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : FiberBundle F E... | true |
Lean.Lsp.instFromJsonLeanImport.fromJson | Lean.Data.Lsp.Extra | Lean.Json → Except String Lean.Lsp.LeanImport | true |
HomologicalComplex.mapBifunctorAssociatorX.congr_simp | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₁₂ : Type u_3} {C₂₃ : Type u_4} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTh... | true |
CategoryTheory.ComonadIso.mk._proof_2 | Mathlib.CategoryTheory.Monad.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {M N : CategoryTheory.Comonad C}
(f : M.toFunctor ≅ N.toFunctor),
(∀ (X : C),
CategoryTheory.CategoryStruct.comp (f.hom.app X) (N.δ.app X) =
CategoryTheory.CategoryStruct.comp (M.δ.app X)
(CategoryTheory.CategoryStruct.comp (f.ho... | false |
Lean.PersistentHashMap._sizeOf_inst | Lean.Data.PersistentHashMap | (α : Type u) →
(β : Type v) → {inst : BEq α} → {inst_1 : Hashable α} → [SizeOf α] → [SizeOf β] → SizeOf (Lean.PersistentHashMap α β) | false |
Subgroup.equivSMul_symm_apply_coe | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {α : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : Group α] [inst_2 : MulDistribMulAction α G] (a : α)
(H : Subgroup G) (y : ↑(⇑↑(MulDistribMulAction.toMulEquiv G a) '' ↑H.toSubmonoid)),
↑((Subgroup.equivSMul a H).symm y) = a⁻¹ • ↑y | true |
MulAction.stabilizerEquivStabilizer_one | Mathlib.GroupTheory.GroupAction.Basic | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α] {a : α},
MulAction.stabilizerEquivStabilizer ⋯ = MulEquiv.refl ↥(MulAction.stabilizer G a) | true |
_private.Batteries.Data.String.Legacy.0.String.Legacy.anyAux._proof_2 | Batteries.Data.String.Legacy | ∀ (s : String) (stopPos i : String.Pos.Raw),
stopPos.byteIdx - (String.Pos.Raw.next s i).byteIdx < stopPos.byteIdx - i.byteIdx →
InvImage (fun x1 x2 => x1 < x2) (fun x => stopPos.byteIdx - x.byteIdx) (String.Pos.Raw.next s i) i | false |
MvPFunctor.wpInd._sunfold | Mathlib.Data.PFunctor.Multivariate.W | {n : ℕ} →
(P : MvPFunctor.{u} (n + 1)) →
{α : TypeVec.{u_1} n} →
{C : (x : P.last.W) → TypeVec.Arrow (P.WPath x) α → Sort v} →
((a : P.A) →
(f : P.last.B a → P.last.W) →
(f' : TypeVec.Arrow (P.WPath (WType.mk a f)) α) →
((i : P.last.B a) → C (f i) (P.wPathDe... | false |
Lean.Meta.ExtractLetsConfig.usedOnly._default | Init.MetaTypes | Bool | false |
Multiset.eq_of_mem_replicate | Mathlib.Data.Multiset.Replicate | ∀ {α : Type u_1} {a b : α} {n : ℕ}, b ∈ Multiset.replicate n a → b = a | true |
_private.Init.Data.UInt.Lemmas.0.UInt16.lt_iff_le_and_ne._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, (a ≤ b) = (a.toNat ≤ b.toNat) | false |
NonUnitalStarAlgHom.realContinuousMapZeroOfNNReal._proof_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | ∀ {X : Type u_2} [inst : TopologicalSpace X] [inst_1 : Zero X] {A : Type u_1} [inst_2 : NonUnitalRing A]
[inst_3 : StarRing A] [inst_4 : Module ℝ A] (φ : ContinuousMapZero X NNReal →⋆ₙₐ[NNReal] A),
φ (ContinuousMapZero.toNNReal 0) - φ (-0).toNNReal = 0 | false |
Finsupp.singleAddHom.eq_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddZeroClass M] (a : ι),
Finsupp.singleAddHom a = { toFun := Finsupp.single a, map_zero' := ⋯, map_add' := ⋯ } | true |
_private.Lean.Elab.Binders.0.Lean.Elab.Term.FunBinders.elabFunBinderViews.match_1 | Lean.Elab.Binders | (motive : Option Lean.Name → Lean.LocalDeclKind → Sort u_1) →
(__do_lift : Option Lean.Name) →
(kind : Lean.LocalDeclKind) →
((className : Lean.Name) → motive (some className) Lean.LocalDeclKind.default) →
((x : Option Lean.Name) → (x_1 : Lean.LocalDeclKind) → motive x x_1) → motive __do_lift kind | false |
Turing.TM2to1.tr_respects_aux₃ | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} [inst : DecidableEq K] (M : Λ → Turing.TM2.Stmt Γ Λ σ)
{q : Turing.TM2.Stmt Γ Λ σ} {v : σ} {L : Turing.ListBlank ((k : K) → Option (Γ k))} (n : ℕ),
StateTransition.Reaches₀ (Turing.TM1.step (Turing.TM2to1.tr M))
{ l := some (Turing.TM2to1.Λ'.ret ... | true |
Finset.isWF._simp_1 | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} [inst : Preorder α] (s : Finset α), (↑s).IsWF = True | false |
_private.Lean.Meta.Tactic.Grind.ProveEq.0.Lean.Meta.Grind.AbstractM.State.rec | Lean.Meta.Tactic.Grind.ProveEq | {motive : Lean.Meta.Grind.AbstractM.State✝ → Sort u} →
((cache : Std.HashMap (Lean.Expr × Lean.Expr) Lean.Expr) →
(varTypes lhss rhss : Array Lean.Expr) →
motive { cache := cache, varTypes := varTypes, lhss := lhss, rhss := rhss }) →
(t : Lean.Meta.Grind.AbstractM.State✝¹) → motive t | false |
CategoryTheory.Square.unopFunctor._proof_6 | Mathlib.CategoryTheory.Square | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X Y Z : (CategoryTheory.Square Cᵒᵖ)ᵒᵖ} (f : X ⟶ Y)
(g : Y ⟶ Z),
{ τ₁ := (CategoryTheory.CategoryStruct.comp f g).unop.τ₄.unop,
τ₂ := (CategoryTheory.CategoryStruct.comp f g).unop.τ₂.unop,
τ₃ := (CategoryTheory.CategoryStruct.comp f g).unop.... | false |
Filter.generate_neBot_iff | Mathlib.Order.Filter.Bases.Finite | ∀ {α : Type u_1} {s : Set (Set α)}, (Filter.generate s).NeBot ↔ ∀ t ⊆ s, t.Finite → (⋂₀ t).Nonempty | true |
Filter.biInter_mem | Mathlib.Order.Filter.Finite | ∀ {α : Type u} {f : Filter α} {β : Type v} {s : β → Set α} {is : Set β},
is.Finite → (⋂ i ∈ is, s i ∈ f ↔ ∀ i ∈ is, s i ∈ f) | true |
IsLocalizedModule.exist_integer_multiples_of_finset | Mathlib.Algebra.Module.LocalizedModule.Int | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) {M : Type u_2} [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] {M' : Type u_3} [inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M')
[IsLocalizedModule S f] (s : Finset M'), ∃ b, ∀ a ∈ s, IsLocalizedModule.IsInteger f (↑b • a) | true |
Ring.DirectLimit.congr | 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} →
{G' : ι → Type u_4} →
[inst_2 : (i : ι) → CommRing (G' i)] →
{f' : (i j : ι) → i ≤ j → G' i →+* G' j} →
(e : (... | true |
Std.Time.PlainTime.fromTime12Hour | Std.Time.Format | String → Except String Std.Time.PlainTime | true |
Lean.Elab.Term.withoutSavingRecAppSyntax | Lean.Elab.Term.TermElabM | {α : Type} → Lean.Elab.TermElabM α → Lean.Elab.TermElabM α | true |
Finsupp.instCoalgebra._proof_1 | Mathlib.RingTheory.Coalgebra.Basic | ∀ (R : Type u_3) (ι : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Coalgebra R A],
↑(TensorProduct.assoc R (ι →₀ A) (ι →₀ A) (ι →₀ A)) ∘ₗ
LinearMap.rTensor (ι →₀ A) CoalgebraStruct.comul ∘ₗ CoalgebraStruct.comul =
LinearMap.lTensor (ι →₀ A) Co... | false |
CategoryTheory.Functor.CorepresentableBy.equivUliftCoyonedaIso._proof_3 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (F : CategoryTheory.Functor C (Type (max u_3 u_2)))
(X : C),
Function.RightInverse
(fun e => { homEquiv := fun {X_1} => Equiv.ulift.symm.trans (equivEquivIso.symm (e.app X_1)), homEquiv_comp := ⋯ })
fun R => CategoryTheory.NatIso.ofComponents (f... | false |
tprod_range | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] {g : γ → β}
(f : β → α), Function.Injective g → ∏' (x : ↑(Set.range g)), f ↑x = ∏' (x : γ), f (g x) | true |
TensorProduct.Algebra.moduleAux._proof_5 | Mathlib.RingTheory.TensorProduct.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
SMulCommClass R R M | false |
MeasureTheory.Content.outerRegular | Mathlib.MeasureTheory.Measure.Content | ∀ {G : Type w} [inst : TopologicalSpace G] (μ : MeasureTheory.Content G) [inst_1 : R1Space G] [S : MeasurableSpace G]
[inst_2 : BorelSpace G], μ.measure.OuterRegular | true |
_private.Lean.Data.Lsp.Ipc.0.Lean.Lsp.Ipc.waitForMessage.loop | Lean.Data.Lsp.Ipc | String → Lean.Lsp.Ipc.IpcM Unit | true |
Sum.instUniformSpace._proof_2 | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β],
∀
x ∈
Filter.map (fun p => (Sum.inl p.1, Sum.inl p.2)) (uniformity α) ⊔
Filter.map (fun p => (Sum.inr p.1, Sum.inr p.2)) (uniformity β),
Prod.swap ⁻¹' x ∈ Filter.map (fun p => (Sum.inl p.1, Sum.inl p.2)) (uniformi... | false |
_private.Init.Data.List.Nat.InsertIdx.0.List.getElem?_insertIdx._proof_1_9 | Init.Data.List.Nat.InsertIdx | ∀ {α : Type u_1} {l : List α} {i j : ℕ}, j = i → i ≤ l.length → ¬j < l.length + 1 → False | false |
CompactExhaustion.isCompact' | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_4} [inst : TopologicalSpace X] (self : CompactExhaustion X) (n : ℕ), IsCompact (self.toFun n) | true |
Int.Linear.Expr.denote._unsafe_rec | Init.Data.Int.Linear | Int.Linear.Context → Int.Linear.Expr → ℤ | false |
Turing.Dir.toCtorIdx | Mathlib.Computability.TuringMachine.Tape | Turing.Dir → ℕ | false |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.IsComplex.cokerToKer'._proof_11 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ}, ∀ k ≤ n, ¬k + 2 ≤ n + 3 → False | false |
Subgroup.strictWidthInfty._proof_1 | Mathlib.NumberTheory.ModularForms.Cusps | ∀ (𝒢 : Subgroup (GL (Fin 2) ℝ)), DiscreteTopology ↥𝒢.strictPeriods → ∃ g, AddSubgroup.zmultiples g = 𝒢.strictPeriods | false |
Batteries.Tactic.Lint.LintVerbosity.ctorIdx | Batteries.Tactic.Lint.Frontend | Batteries.Tactic.Lint.LintVerbosity → ℕ | false |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.Nat.isSemilinearSet_inter_of_isLinearSet._simp_1_2 | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {P : α → Prop} {Q : β → Prop}, ((∃ a, P a) ∧ ∃ b, Q b) = ∃ a b, P a ∧ Q b | false |
Subfield.coe_inv._simp_1 | Mathlib.Algebra.Field.Subfield.Defs | ∀ {K : Type u} [inst : DivisionRing K] (s : Subfield K) (x : ↥s), (↑x)⁻¹ = ↑x⁻¹ | false |
Fin.castAddEmb | Mathlib.Data.Fin.Embedding | {n : ℕ} → (m : ℕ) → Fin n ↪ Fin (n + m) | true |
Mathlib.Tactic.Order.Graph.TarjanState.mk._flat_ctor | Mathlib.Tactic.Order.Graph.Tarjan | Std.HashSet ℕ → Std.HashMap ℕ ℕ → Std.HashMap ℕ ℕ → Array ℕ → Std.HashSet ℕ → ℕ → Mathlib.Tactic.Order.Graph.TarjanState | false |
_private.Init.Data.Iterators.Lemmas.Combinators.FlatMap.0.Std.Iter.step_flatMapAfterM.match_3.splitter | Init.Data.Iterators.Lemmas.Combinators.FlatMap | {α₂ γ : Type u_1} →
{m : Type u_1 → Type u_2} →
[inst : Std.Iterator α₂ m γ] →
(it₂ : Std.IterM m γ) →
(motive : it₂.Step → Sort u_3) →
(x : it₂.Step) →
((it₂' : Std.IterM m γ) →
(out : γ) →
(h : it₂.IsPlausibleStep (Std.IterStep.yield it₂' out... | true |
_private.Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero.0.Localization.instCommMonoidWithZero._simp_1 | Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {a c : M} {b d : ↥S},
(Localization.mk a b = Localization.mk c d) = (Localization.r S) (a, b) (c, d) | false |
MonoidAlgebra.comapDistribMulActionSelf | Mathlib.Algebra.MonoidAlgebra.Module | {k : Type u₁} → {G : Type u₂} → [inst : Group G] → [inst_1 : Semiring k] → DistribMulAction G (MonoidAlgebra k G) | true |
pointedToBipointedSndBipointedToPointedSndAdjunction._proof_4 | Mathlib.CategoryTheory.Category.Bipointed | ∀ {X : Pointed} {Y Y' : Bipointed} (f : pointedToBipointedSnd.obj X ⟶ Y) (g : Y ⟶ Y'),
{ toFun := fun f => { toFun := f.toFun ∘ some, map_point := ⋯ },
invFun := fun f => { toFun := fun o => Option.elim o Y'.toProd.1 f.toFun, map_fst := ⋯, map_snd := ⋯ },
left_inv := ⋯, right_inv := ⋯ }
(Categor... | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.InitResults.mk._flat_ctor | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | {α : Type} →
Lean.Meta.RefinedDiscrTree.PreDiscrTree α →
Array Lean.Meta.RefinedDiscrTree.ImportFailure✝ → Lean.Meta.RefinedDiscrTree.InitResults✝ α | false |
AddChar.expect_apply_ne_zero_iff_eq_zero | Mathlib.Analysis.Fourier.FiniteAbelian.PontryaginDuality | ∀ {α : Type u_1} [inst : AddCommGroup α] {a : α} [inst_1 : Finite α], (Finset.univ.expect fun ψ => ψ a) ≠ 0 ↔ a = 0 | true |
Std.Time.PlainDate.withWeekday | Std.Time.Date.PlainDate | Std.Time.PlainDate → Std.Time.Weekday → Std.Time.PlainDate | true |
Seminorm.mem_closedBall_zero | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : SMul 𝕜 E]
(p : Seminorm 𝕜 E) {y : E} {r : ℝ}, y ∈ p.closedBall 0 r ↔ p y ≤ r | true |
_private.Mathlib.Topology.MetricSpace.HausdorffDistance.0.IsOpen.exists_iUnion_isClosed._simp_1_5 | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ici b) = (b ≤ x) | false |
Fin.instNonUnitalCommRing._proof_4 | Mathlib.Data.ZMod.Defs | ∀ (n : ℕ) (a b : Fin n), a * b = b * a | false |
ωCPO.HasEqualizers.isEqualizer._proof_6 | Mathlib.Order.Category.OmegaCompletePartialOrder | ∀ {X Y : ωCPO} (f g : X ⟶ Y) (s : CategoryTheory.Limits.Fork f g) (x : OmegaCompletePartialOrder.Chain s.pt.carrier),
⟨(CategoryTheory.ConcreteCategory.hom s.ι) (OmegaCompletePartialOrder.ωSup x), ⋯⟩ =
OmegaCompletePartialOrder.ωSup
(x.map { toFun := fun x => ⟨(CategoryTheory.ConcreteCategory.hom s.ι) x, ⋯⟩... | false |
Aesop.RuleTac.ForwardM.Context.forwardHypData | Aesop.RuleTac.Forward | Aesop.RuleTac.ForwardM.Context → Aesop.ForwardHypData | true |
MeasureTheory.measurableSet_exists_tendsto | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {ι : Type u_2} {γ : Type u_3} {β : Type u_5} [inst : MeasurableSpace β] [inst_1 : TopologicalSpace γ] [PolishSpace γ]
[inst_3 : MeasurableSpace γ] [hγ : OpensMeasurableSpace γ] [Countable ι] {l : Filter ι} [l.IsCountablyGenerated]
{f : ι → β → γ}, (∀ (i : ι), Measurable (f i)) → MeasurableSet {x | ∃ c, Filter.Ten... | true |
DiffeologicalSpace.CorePlotsOn.mk.injEq | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1}
(isPlotOn : {n : ℕ} → {u : Set (EuclideanSpace ℝ (Fin n))} → IsOpen u → (EuclideanSpace ℝ (Fin n) → X) → Prop)
(isPlotOn_congr :
∀ {n : ℕ} {u : Set (EuclideanSpace ℝ (Fin n))} (hu : IsOpen u) {p q : EuclideanSpace ℝ (Fin n) → X},
Set.EqOn p q u → (isPlotOn hu p ↔ isPlotOn hu q))
(isPlot... | true |
MeasureTheory.eq_add_disjointOfDiff_of_subset | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} {C : Set (Set α)} {s t : Set α} {G : Type u_2} [inst : AddCommMonoid G]
{m : MeasureTheory.AddContent G C} (hC : MeasureTheory.IsSetSemiring C) (hs : s ∈ C) (ht : t ∈ C),
s ⊆ t → m t = m s + ∑ i ∈ hC.disjointOfDiff ht hs, m i | true |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.hqhom | Mathlib.RingTheory.Smooth.NoetherianDescent | ∀ {A : Type u} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
(self : Algebra.Smooth.DescentAux✝ A B) (i : Algebra.Smooth.DescentAux.vars✝ self),
(Algebra.Smooth.DescentAux.q✝ self i).IsHomogeneous 1 | true |
ValuationRing.equivInteger._proof_6 | Mathlib.RingTheory.Valuation.ValuationRing | ∀ (A : Type u_2) [inst : CommRing A] (K : Type u_1) [inst_1 : Field K] [inst_2 : Algebra A K] [inst_3 : IsDomain A]
[inst_4 : ValuationRing A] [inst_5 : IsFractionRing A K] (a : A),
(algebraMap A K) a ∈ (ValuationRing.valuation A K).integer | false |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State.rec | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | {motive : Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State → Sort u} →
((bottomUps higherOrders funBinders provideds : Array Bool) →
(namedArgs : Array Lean.Name) →
motive
{ bottomUps := bottomUps, higherOrders := higherOrders, funBinders := funBinders, provideds := provideds,
... | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point.0.WeierstrassCurve.Affine.Point.eq_or_eq_neg_of_xRep_eq_xRep._simp_1_6 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {α : Type u} {n : ℕ} {x y : α} {u v : Fin n → α}, (Matrix.vecCons x u = Matrix.vecCons y v) = (x = y ∧ u = v) | false |
Sum.not_inl_le_inr._simp_1 | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] {a : α} {b : β}, (Sum.inl b ≤ Sum.inr a) = False | false |
Set.prod_subset_prod_iff | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s s₁ : Set α} {t t₁ : Set β}, s ×ˢ t ⊆ s₁ ×ˢ t₁ ↔ s ⊆ s₁ ∧ t ⊆ t₁ ∨ s = ∅ ∨ t = ∅ | true |
Metric.edist_le_of_ediam_le | Mathlib.Topology.EMetricSpace.Diam | ∀ {X : Type u_2} {s : Set X} {x y : X} [inst : PseudoEMetricSpace X] {d : ENNReal},
x ∈ s → y ∈ s → Metric.ediam s ≤ d → edist x y ≤ d | true |
_private.Mathlib.Tactic.FunProp.FunctionData.0.Mathlib.Meta.FunProp.getFunctionData?.match_4 | Mathlib.Tactic.FunProp.FunctionData | (motive : Lean.Expr → Sort u_1) →
(__discr : Lean.Expr) →
((xName : Lean.Name) →
(xType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE xName xType body binderInfo)) →
((x : Lean.Expr) → motive x) → motive __discr | false |
_private.Mathlib.Data.EReal.Basic.0.EReal.coe_toReal_le._simp_1_1 | Mathlib.Data.EReal.Basic | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True | false |
_private.Mathlib.GroupTheory.Archimedean.0.Subgroup.exists_isLeast_one_lt._simp_1_6 | Mathlib.GroupTheory.Archimedean | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | false |
NumberField.mixedEmbedding.negAt_signSet_apply_isComplex | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {K : Type u_1} [inst : Field K] (x : NumberField.mixedEmbedding.mixedSpace K) (w : { w // w.IsComplex }),
((NumberField.mixedEmbedding.negAt (NumberField.mixedEmbedding.signSet x)) x).2 w = x.2 w | true |
CategoryTheory.Oplax.StrongTrans.Modification.naturality_assoc | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} {η θ : F ⟶ G} (self : CategoryTheory.Oplax.StrongTrans.Modification η θ)
{a b : B} (f : a ⟶ b) {Z : F.obj a ⟶ G.obj b} (h : CategoryTheory.CategoryStruct.comp (θ.app a) (... | true |
CategoryTheory.LeftExactFunctor.fullyFaithful | Mathlib.CategoryTheory.Limits.ExactFunctor | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(D : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → (CategoryTheory.LeftExactFunctor.forget C D).FullyFaithful | true |
_private.Mathlib.MeasureTheory.Constructions.Polish.Basic.0.MeasureTheory.wrapped._proof_1._@.Mathlib.MeasureTheory.Constructions.Polish.Basic.3011411360._hygCtx._hyg.2 | Mathlib.MeasureTheory.Constructions.Polish.Basic | @MeasureTheory.definition✝ = @MeasureTheory.definition✝ | false |
_private.Init.NotationExtra.0.Lean.expandExplicitBindersAux.loop._unsafe_rec | Init.NotationExtra | Lean.Syntax →
(idents : Array Lean.Syntax) → Option Lean.Syntax → (i : ℕ) → i ≤ idents.size → Lean.Syntax → Lean.MacroM Lean.Syntax | false |
ContDiffWithinAt.prodMap | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : WithTop ℕ∞}
{E' : Type u_3} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSpace 𝕜 E'] {F' : Type u_4}
[... | true |
Mathlib.Linter.TextBased.linter.whitespaceBeforeSemicolon | Mathlib.Tactic.Linter.TextBased | Lean.Option Bool | true |
Std.TreeSet.Raw.minD_insert_of_isEmpty | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, t.isEmpty = true → ∀ {fallback : α}, (t.insert k).minD fallback = k | true |
CategoryTheory.InducedWideCategory.Hom.mk._flat_ctor | Mathlib.CategoryTheory.Widesubcategory | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₂} D] →
{F : C → D} →
{P : CategoryTheory.MorphismProperty D} →
[inst_1 : P.IsMultiplicative] →
{X Y : CategoryTheory.InducedWideCategory D F P} → (hom : F X ⟶ F Y) → P hom → X.Hom Y | false |
ProbabilityTheory.IsGaussianProcess.hasGaussianLaw | Mathlib.Probability.Distributions.Gaussian.IsGaussianProcess.Def | ∀ {Ω : Type u_1} {E : Type u_2} {T : Type u_3} {mΩ : MeasurableSpace Ω} [inst : MeasurableSpace E]
[inst_1 : TopologicalSpace E] [inst_2 : AddCommMonoid E] [inst_3 : Module ℝ E] {X : T → Ω → E}
{P : autoParam (MeasureTheory.Measure Ω) ProbabilityTheory.IsGaussianProcess._auto_1},
ProbabilityTheory.IsGaussianProce... | true |
MulAction.toFun | Mathlib.Algebra.Group.Action.Basic | (M : Type u_2) → (α : Type u_5) → [inst : Monoid M] → [MulAction M α] → α ↪ M → α | true |
QuasiSober.recOn | Mathlib.Topology.Sober | {α : Type u_3} →
[inst : TopologicalSpace α] →
{motive : QuasiSober α → Sort u} →
(t : QuasiSober α) →
((sober : ∀ {S : Set α}, IsIrreducible S → IsClosed S → ∃ x, IsGenericPoint x S) → motive ⋯) → motive t | false |
Algebra.TensorProduct.not_isField_of_transcendental | Mathlib.RingTheory.LinearDisjoint | ∀ (R : Type u) [inst : CommRing R] (A : Type v) [inst_1 : CommRing A] (B : Type w) [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [Module.Flat R A] [Module.Flat R B] [Algebra.Transcendental R A]
[Algebra.Transcendental R B], ¬IsField (TensorProduct R A B) | true |
Lean.instReprTraceResult | Lean.Message | Repr Lean.TraceResult | true |
Squarefree.dvd_pow_iff_dvd | Mathlib.Algebra.Squarefree.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] [DecompositionMonoid R] {x y : R} {n : ℕ},
Squarefree x → n ≠ 0 → (x ∣ y ^ n ↔ x ∣ y) | true |
Set.«_aux_Mathlib_Order_SetNotation___delab_app_Set_term⋂_,__1» | Mathlib.Order.SetNotation | Lean.PrettyPrinter.Delaborator.Delab | false |
Multiset.zero_ne_singleton._simp_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} (a : α), (0 = {a}) = False | false |
MoritaEquivalence.recOn | Mathlib.RingTheory.Morita.Basic | {R : Type u₀} →
[inst : CommSemiring R] →
{A : Type u₁} →
[inst_1 : Ring A] →
[inst_2 : Algebra R A] →
{B : Type u₂} →
[inst_3 : Ring B] →
[inst_4 : Algebra R B] →
{motive : MoritaEquivalence R A B → Sort u} →
(t : MoritaEquivalen... | false |
LinearMap.toContPerfPair._proof_4 | Mathlib.Topology.Algebra.Module.PerfectPairing | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : TopologicalSpace R] [IsTopologicalRing R], ContinuousAdd R | false |
String.Legacy.contains | Batteries.Data.String.Legacy | String → Char → Bool | true |
CategoryTheory.Preadditive.commGrpEquivalence_counitIso_hom_app_hom_hom_hom | Mathlib.CategoryTheory.Preadditive.CommGrp_ | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] [inst_3 : CategoryTheory.BraidedCategory C]
(X : CategoryTheory.CommGrp C),
(CategoryTheory.Preadditive.commGrpEquivalence.counitIso.hom.app X).hom.hom.hom = Categ... | true |
Matroid.restrictSubtype_ground_isBasis_iff._simp_1 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {M : Matroid α} {I X : Set ↑M.E},
(M.restrictSubtype M.E).IsBasis I X = M.IsBasis (Subtype.val '' I) (Subtype.val '' X) | false |
Equiv.Perm.viaEmbedding_apply | Mathlib.GroupTheory.Perm.ViaEmbedding | ∀ {α : Type u_1} {β : Type u_2} (e : Equiv.Perm α) (ι : α ↪ β) (x : α), (e.viaEmbedding ι) (ι x) = ι (e x) | true |
Std.Iter.all_mapM | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β β' : Type w} {m : Type w → Type w'} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id]
[inst_2 : Std.IteratorLoop α Id m] [inst_3 : Monad m] [inst_4 : MonadAttach m] [LawfulMonad m]
[WeaklyLawfulMonadAttach m] [Std.LawfulIteratorLoop α Id m] {it : Std.Iter β} {f : β → m β'} {p : β' → Bool},
Std.IterM... | true |
Polynomial.coeff_ofNat_zero | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (a : ℕ) [inst_1 : a.AtLeastTwo], (OfNat.ofNat a).coeff 0 = OfNat.ofNat a | true |
Module.dualProdDualEquivDual._proof_1 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ (R : Type u_1) [inst : CommSemiring R], SMulCommClass R R R | false |
Std.CancellationContext.State.noConfusion | Std.Sync.CancellationContext | {P : Sort u} → {t t' : Std.CancellationContext.State} → t = t' → Std.CancellationContext.State.noConfusionType P t t' | false |
_private.Mathlib.NumberTheory.Padics.Hensel.0.ih_n._proof_1 | Mathlib.NumberTheory.Padics.Hensel | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommSemiring R] [inst_2 : Algebra R ℤ_[p]]
{F : Polynomial R} {a : ℤ_[p]},
‖(Polynomial.aeval a) F‖ < ‖(Polynomial.aeval a) (Polynomial.derivative F)‖ ^ 2 →
∀ {n : ℕ} {z : ℤ_[p]},
ih_gen✝ n z →
∀ (h1 : ‖↑((Polynomial.aeval z) F) / ↑((P... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.