name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.Time.Text.noConfusion | Std.Time.Format.Basic | {P : Sort v✝} → {x y : Std.Time.Text} → x = y → Std.Time.Text.noConfusionType P x y | false |
Lean.Elab.Term.ElabElim.setMotive | Lean.Elab.App | Lean.Expr → Lean.Elab.Term.ElabElim.M Unit | true |
Manifold.IsImmersionAt.writtenInCharts | Mathlib.Geometry.Manifold.Immersion | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} {E'' : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E''] [inst_4 : NormedSpace 𝕜 E''] {H : Type u_7}
[inst_5 : TopologicalSpace H] {G : Type u_9} [inst_6 : TopologicalSpace G] {I : ModelWithCorners 𝕜 E H}
{J : ModelWithCorners 𝕜 E'' G} {M : Type u_11} [inst_7 : TopologicalSpace M] [inst_8 : ChartedSpace H M]
{N : Type u_13} [inst_9 : TopologicalSpace N] [inst_10 : ChartedSpace G N] {n : WithTop ℕ∞} {f : M → N} {x : M}
(h : Manifold.IsImmersionAt I J n f x),
Set.EqOn (↑(h.codChart.extend J) ∘ f ∘ ↑(h.domChart.extend I).symm) (⇑h.equiv ∘ fun x_1 => (x_1, 0))
(h.domChart.extend I).target | true |
Nat.sub_one_eq_self | Init.Data.Nat.Basic | ∀ {n : ℕ}, n - 1 = n ↔ n = 0 | true |
_private.Mathlib.Combinatorics.Additive.ApproximateSubgroup.0.isApproximateSubgroup_one._simp_1_3 | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {α : Type u_1} {s : Finset α} {a : α}, (s ⊆ {a}) = (s = ∅ ∨ s = {a}) | false |
continuousWithinAt_Ico_iff_Iio._simp_1 | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [ClosedIicTopology α]
[inst_3 : TopologicalSpace β] {a b : α} {f : α → β},
a < b → ContinuousWithinAt f (Set.Ico a b) b = ContinuousWithinAt f (Set.Iio b) b | false |
northcott_iff | Mathlib.NumberTheory.Height.Northcott | ∀ {α : Type u_1} {β : Type u_2} (h : α → β) [inst : LE β], Northcott h ↔ ∀ (b : β), {a | h a ≤ b}.Finite | true |
Std.DTreeMap.Internal.Impl.Const.alter._proof_16 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : Type u_2} (k : α) (v : β),
(Std.DTreeMap.Internal.Impl.inner 1 k v Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf).size ≤
Std.DTreeMap.Internal.Impl.leaf.size + 1 | false |
Lean.Elab.Term.StructInst.FieldLHS._sizeOf_inst | Lean.Elab.StructInst | SizeOf Lean.Elab.Term.StructInst.FieldLHS | false |
Std.Internal.List.getKey | Std.Data.Internal.List.Associative | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] → (a : α) → (l : List ((a : α) × β a)) → Std.Internal.List.containsKey a l = true → α | true |
Set.Icc_subset_Icc_left | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b : α}, a₁ ≤ a₂ → Set.Icc a₂ b ⊆ Set.Icc a₁ b | true |
CategoryTheory.Limits.BinaryCofan | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {C : Type u} → [CategoryTheory.Category.{v, u} C] → C → C → Type (max (max 0 u) v) | true |
Nucleus.map_himp_apply | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : Order.Frame X] (n : Nucleus X) (x y : X), n (x ⇨ n y) = x ⇨ n y | true |
MeasureTheory.condExp_mul_of_stronglyMeasurable_right | Mathlib.MeasureTheory.Function.ConditionalExpectation.PullOut | ∀ {Ω : Type u_1} {m mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {f g : Ω → ℝ},
MeasureTheory.StronglyMeasurable g →
MeasureTheory.Integrable (f * g) μ → MeasureTheory.Integrable f μ → μ[f * g | m] =ᵐ[μ] μ[f | m] * g | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList._proof_1_12 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {stackPos needlePos : String.Pos.Raw},
needlePos.byteIdx ≤ stackPos.byteIdx → ¬needlePos.byteIdx = 0 → ¬needlePos.byteIdx - 1 < stackPos.byteIdx → False | false |
Lean.Parser.Tactic.decide | Init.Tactics | Lean.ParserDescr | true |
_private.Batteries.Data.List.Basic.0.List.takeWhile₂TR.go.match_1.splitter._sparseCasesOn_2 | Batteries.Data.List.Basic | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
UInt32.fromExpr | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.Expr → Lean.Meta.SimpM (Option UInt32) | true |
Matrix.UnitaryGroup.toLinearEquiv._proof_7 | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u_1} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type u_2} [inst_2 : CommRing α] [inst_3 : StarRing α]
(A : ↥(Matrix.unitaryGroup n α)) (x : n → α), (Matrix.UnitaryGroup.toLin' A ∘ₗ Matrix.UnitaryGroup.toLin' A⁻¹) x = x | false |
BialgHom.coe_toAlgHom | Mathlib.RingTheory.Bialgebra.Hom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : CoalgebraStruct R A] [inst_6 : CoalgebraStruct R B]
(f : A →ₐc[R] B), ⇑↑f = ⇑f | true |
Std.DTreeMap.Raw.minKey!_insert | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α],
t.WF →
∀ {k : α} {v : β k}, (t.insert k v).minKey! = t.minKey?.elim k fun k' => if (cmp k k').isLE = true then k else k' | true |
Std.TreeSet.Raw.min?_eq_some_min! | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.WF → t.isEmpty = false → t.min? = some t.min! | true |
ProbabilityTheory.iIndepFun.hasGaussianLaw_fun_add | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Independence | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {E : Type u_2} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E] [SecondCountableTopology E] [CompleteSpace E]
{X Y : Ω → E},
ProbabilityTheory.HasGaussianLaw X P →
ProbabilityTheory.HasGaussianLaw Y P →
ProbabilityTheory.IndepFun X Y P → ProbabilityTheory.HasGaussianLaw (fun ω => X ω + Y ω) P | true |
Std.Sat.AIG.denote_idx_trichotomy | Std.Sat.AIG.Lemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {start : ℕ} {assign : α → Bool} {invert res : Bool}
{aig : Std.Sat.AIG α} {hstart : start < aig.decls.size},
(aig.decls[start] = Std.Sat.AIG.Decl.false →
⟦assign, { aig := aig, ref := { gate := start, invert := invert, hgate := hstart } }⟧ = res) →
(∀ (a : α),
aig.decls[start] = Std.Sat.AIG.Decl.atom a →
⟦assign, { aig := aig, ref := { gate := start, invert := invert, hgate := hstart } }⟧ = res) →
(∀ (lhs rhs : Std.Sat.AIG.Fanin),
aig.decls[start] = Std.Sat.AIG.Decl.gate lhs rhs →
⟦assign, { aig := aig, ref := { gate := start, invert := invert, hgate := hstart } }⟧ = res) →
⟦assign, { aig := aig, ref := { gate := start, invert := invert, hgate := hstart } }⟧ = res | true |
PreQuasiregular.instMonoid._proof_1 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] (x y z : PreQuasiregular R),
PreQuasiregular.equiv.symm (x * y * z) = PreQuasiregular.equiv.symm (x * (y * z)) | false |
OreLocalization.mul_cancel | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {r : R} {s t : ↥S},
↑s /ₒ t * (r /ₒ s) = r /ₒ t | true |
ProbabilityTheory.Kernel.fst_prod | Mathlib.Probability.Kernel.Composition.Prod | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
{mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsSFiniteKernel κ]
(η : ProbabilityTheory.Kernel α γ) [ProbabilityTheory.IsMarkovKernel η], (κ.prod η).fst = κ | true |
Std.ExtHashMap.getKey_union_of_not_mem_right | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} (not_mem : k ∉ m₂) {h' : k ∈ m₁ ∪ m₂}, (m₁ ∪ m₂).getKey k h' = m₁.getKey k ⋯ | true |
CategoryTheory.Iso.op._proof_2 | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (α : X ≅ Y),
CategoryTheory.CategoryStruct.comp α.inv.op α.hom.op = CategoryTheory.CategoryStruct.id (Opposite.op X) | false |
Polynomial.ofFinsupp_eq_one | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] {a : AddMonoidAlgebra R ℕ}, { toFinsupp := a } = 1 ↔ a = 1 | true |
AndOp.rec | Init.Prelude | {α : Type u} → {motive : AndOp α → Sort u_1} → ((and : α → α → α) → motive { and := and }) → (t : AndOp α) → motive t | false |
toIcoDiv_sub_ofNat_mul | Mathlib.Algebra.Order.ToIntervalMod | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : LinearOrder R] [inst_2 : IsOrderedAddMonoid R]
[inst_3 : Archimedean R] {p : R} (hp : 0 < p) (a b : R) (m : ℕ) [inst_4 : m.AtLeastTwo],
toIcoDiv hp a (b - OfNat.ofNat m * p) = toIcoDiv hp a b - OfNat.ofNat m | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1.stmts_supportsStmt._simp_1_6 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, ((∃ x, p x) → b) = ∀ (x : α), p x → b | false |
MDifferentiableOn.apply_eq_of_isPreconnected_isCompact_isOpen | Mathlib.Geometry.Manifold.Complex | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {F : Type u_2} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℂ F] {H : Type u_3} [inst_4 : TopologicalSpace H] {I : ModelWithCorners ℂ E H} [I.Boundaryless]
{M : Type u_4} [inst_6 : TopologicalSpace M] [inst_7 : ChartedSpace H M] [IsManifold I 1 M] {f : M → F} {U : Set M}
{a b : M}, MDiff[U] f → IsPreconnected U → IsCompact U → IsOpen U → a ∈ U → b ∈ U → f a = f b | true |
CategoryTheory.Pairwise.Hom.id_single.elim | Mathlib.CategoryTheory.Category.Pairwise | {ι : Type v} →
{motive : (a a_1 : CategoryTheory.Pairwise ι) → a.Hom a_1 → Sort u} →
{a a_1 : CategoryTheory.Pairwise ι} →
(t : a.Hom a_1) →
t.ctorIdx = 0 →
((i : ι) →
motive (CategoryTheory.Pairwise.single i) (CategoryTheory.Pairwise.single i)
(CategoryTheory.Pairwise.Hom.id_single i)) →
motive a a_1 t | false |
Finset.cons._proof_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} (a : α) (s : Finset α), a ∉ s → (a ::ₘ s.val).Nodup | false |
SimpleGraph.recolorOfEmbedding._proof_2 | Mathlib.Combinatorics.SimpleGraph.Coloring.VertexColoring | ∀ {V : Type u_1} (G : SimpleGraph V) {α : Type u_2} {β : Type u_3} (f : α ↪ β) (C C' : G.Coloring α),
(SimpleGraph.Embedding.completeGraph f).toHom.comp C = (SimpleGraph.Embedding.completeGraph f).toHom.comp C' →
{ toFun := ⇑C, map_rel' := ⋯ } = { toFun := ⇑C', map_rel' := ⋯ } | false |
instGroupLex | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [h : Group α] → Group (Lex α) | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.step_filterMapWithPostcondition.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {β β' : Type u_1} {n : Type u_1 → Type u_2} {f : β → Std.Iterators.PostconditionT n (Option β')} (out : β)
(motive : Subtype (f out).Property → Sort u_3) (h' : (f out).Property none)
(h_1 : (h' : (f out).Property none) → motive ⟨none, h'⟩)
(h_2 : (out' : β') → (h' : (f out).Property (some out')) → motive ⟨some out', h'⟩),
(match ⟨none, h'⟩ with
| ⟨none, h'⟩ => h_1 h'
| ⟨some out', h'⟩ => h_2 out' h') =
h_1 h' | true |
_private.Mathlib.Tactic.FunProp.Theorems.0.Mathlib.Meta.FunProp.instReprTheoremForm.repr.match_1 | Mathlib.Tactic.FunProp.Theorems | (motive : Mathlib.Meta.FunProp.TheoremForm → Sort u_1) →
(x : Mathlib.Meta.FunProp.TheoremForm) →
(Unit → motive Mathlib.Meta.FunProp.TheoremForm.uncurried) →
(Unit → motive Mathlib.Meta.FunProp.TheoremForm.comp) → motive x | false |
Algebra.PreSubmersivePresentation.cotangentComplexAux._proof_4 | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | ∀ {R : Type u_1} {S : Type u_3} {ι : Type u_2} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] (P : Algebra.PreSubmersivePresentation R S ι σ), SMulCommClass P.toExtension.Ring S S | false |
_private.Mathlib.Topology.Separation.Regular.0.TopologicalSpace.IsTopologicalBasis.exists_closure_subset._simp_1_2 | Mathlib.Topology.Separation.Regular | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | false |
ValuativeRel.RankLeOneStruct.strictMono | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] (self : ValuativeRel.RankLeOneStruct R),
StrictMono ⇑self.emb | true |
Lean.Lsp.instFileSourceDidSaveTextDocumentParams | Lean.Server.FileSource | Lean.Lsp.FileSource Lean.Lsp.DidSaveTextDocumentParams | true |
NonUnitalStarSubalgebra.toNonUnitalSemiring | Mathlib.Algebra.Star.NonUnitalSubalgebra | {R : Type u_1} →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalSemiring A] →
[inst_2 : Module R A] → [inst_3 : Star A] → (S : NonUnitalStarSubalgebra R A) → NonUnitalSemiring ↥S | true |
List.length_take | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {i : ℕ} {l : List α}, (List.take i l).length = min i l.length | true |
_private.Init.Data.List.Erase.0.List.erase_eq_iff._simp_1_1 | Init.Data.List.Erase | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | false |
Array.isEmpty_replicate | Init.Data.Array.Lemmas | ∀ {n : ℕ} {α : Type u_1} {a : α}, (Array.replicate n a).isEmpty = decide (n = 0) | true |
_private.Lean.Compiler.LCNF.Simp.InlineProj.0.Lean.Compiler.LCNF.Simp.inlineProjInst?.visit.match_12 | Lean.Compiler.LCNF.Simp.InlineProj | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((ctorVal : Lean.ConstructorVal) → motive (some (Lean.ConstantInfo.ctorInfo ctorVal))) →
((x : Option Lean.ConstantInfo) → motive x) → motive x | false |
_private.Lean.Meta.Match.SimpH.0.Lean.Meta.Match.SimpH.processNextEq.match_12 | Lean.Meta.Match.SimpH | (motive : List Lean.FVarId → Sort u_1) →
(x : List Lean.FVarId) →
((eq : Lean.FVarId) → (eqs : List Lean.FVarId) → motive (eq :: eqs)) →
((x : List Lean.FVarId) → motive x) → motive x | false |
AdjoinRoot.isAdjoinRootMonic | Mathlib.RingTheory.IsAdjoinRoot | {R : Type u} → [inst : CommRing R] → (f : Polynomial R) → f.Monic → IsAdjoinRootMonic (AdjoinRoot f) f | true |
_private.Mathlib.Combinatorics.Colex.0.Finset.Colex.singleton_le_singleton._simp_1_2 | Mathlib.Combinatorics.Colex | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | false |
_private.Init.Grind.Module.Envelope.0.Lean.Grind.IntModule.OfNatModule.zsmul._proof_1 | Init.Grind.Module.Envelope | ∀ {α : Type u_1} [inst : Lean.Grind.NatModule α] (n : ℤ) (h : α × α) (b : α × α),
Lean.Grind.IntModule.OfNatModule.r α h b →
(match h with
| (a, b) =>
if n < 0 then Lean.Grind.IntModule.OfNatModule.Q.mk (n.natAbs • b, n.natAbs • a)
else Lean.Grind.IntModule.OfNatModule.Q.mk (n.natAbs • a, n.natAbs • b)) =
match b with
| (a, b) =>
if n < 0 then Lean.Grind.IntModule.OfNatModule.Q.mk (n.natAbs • b, n.natAbs • a)
else Lean.Grind.IntModule.OfNatModule.Q.mk (n.natAbs • a, n.natAbs • b) | false |
_private.Lean.PrettyPrinter.Delaborator.FieldNotation.0.Lean.PrettyPrinter.Delaborator.generalizedFieldInfo | Lean.PrettyPrinter.Delaborator.FieldNotation | Lean.Name → Array Lean.Expr → Lean.MetaM (Lean.Name × ℕ) | true |
Lean.PrettyPrinter.Parenthesizer.State.ctorIdx | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer.State → ℕ | false |
Module.associatedPrimes.mem_associatePrimes_localizedModule_atPrime_of_mem_associated_primes | Mathlib.RingTheory.Ideal.AssociatedPrime.Localization | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_3} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {p : Ideal R}
[inst_3 : p.IsPrime],
p ∈ associatedPrimes R M →
IsLocalRing.maximalIdeal (Localization.AtPrime p) ∈
associatedPrimes (Localization.AtPrime p) (LocalizedModule.AtPrime p M) | true |
Lean.Compiler.LCNF.StructProjCases.M.run | Lean.Compiler.LCNF.StructProjCases | {α : Type} → Lean.Compiler.LCNF.StructProjCases.M α → Lean.Compiler.LCNF.CompilerM α | true |
CategoryTheory.GrothendieckTopology.diagramNatTrans_comp | Mathlib.CategoryTheory.Sites.Plus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
{P Q R : CategoryTheory.Functor Cᵒᵖ D} (η : P ⟶ Q) (γ : Q ⟶ R) (X : C),
J.diagramNatTrans (CategoryTheory.CategoryStruct.comp η γ) X =
CategoryTheory.CategoryStruct.comp (J.diagramNatTrans η X) (J.diagramNatTrans γ X) | true |
Option.get_map._proof_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {o : Option α} {h : (Option.map f o).isSome = true}, o.isSome = true | false |
Ordinal.IsNormal.veblenWith_zero | Mathlib.SetTheory.Ordinal.Veblen | ∀ {f : Ordinal.{u} → Ordinal.{u}}, Order.IsNormal f → 0 < f 0 → Order.IsNormal fun x => Ordinal.veblenWith f x 0 | true |
Path.toHomotopyConst | Mathlib.Topology.Homotopy.Path | {X : Type u} →
{Y : Type v} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{x₀ x₁ : X} → Path x₀ x₁ → (ContinuousMap.const Y x₀).Homotopy (ContinuousMap.const Y x₁) | true |
CategoryTheory.Limits.initialIsInitial._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Terminal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasInitial C]
(s : CategoryTheory.Limits.Cocone (CategoryTheory.Functor.empty C)) (j : CategoryTheory.Discrete PEmpty.{1}),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Limits.asEmptyCocone (⊥_ C)).ι.app j)
(CategoryTheory.Limits.initial.to s.pt) =
s.ι.app j | false |
Prod.instCompleteAtomicBooleanAlgebra._proof_6 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteAtomicBooleanAlgebra α] [inst_1 : CompleteAtomicBooleanAlgebra β]
(a b : α × β), Lattice.inf a b ≤ b | false |
Finset.pairwiseDisjoint_filter | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {f : α → Finset β},
(↑s).PairwiseDisjoint f →
∀ (p : β → Prop) [inst : DecidablePred p], (↑s).PairwiseDisjoint fun a => Finset.filter p (f a) | true |
Std.Internal.IO.Async.System.OSInfo.machine | Std.Internal.Async.System | Std.Internal.IO.Async.System.OSInfo → String | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Nat.mkDecideProofEq | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc | Lean.Expr → Lean.Expr → Lean.Expr | true |
Std.Internal.Async.IO.AsyncRead.recOn | Std.Internal.Async.IO | {α β : Type} →
{motive : Std.Internal.Async.IO.AsyncRead α β → Sort u} →
(t : Std.Internal.Async.IO.AsyncRead α β) →
((read : α → Std.Internal.IO.Async.Async β) → motive { read := read }) → motive t | false |
Lean.Compiler.LCNF.Param.applyRenaming | Lean.Compiler.LCNF.Renaming | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Param pu → Lean.Compiler.LCNF.Renaming → Lean.Compiler.LCNF.CompilerM (Lean.Compiler.LCNF.Param pu) | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.registerSolverExtension.unsafe_1 | Lean.Meta.Tactic.Grind.Types | {σ : Type} → Lean.Meta.Grind.SolverExtension σ → Lean.Meta.Grind.SolverExtension Lean.Meta.Grind.SolverExtensionState | true |
Lean.Meta.Canonicalizer.State._sizeOf_1 | Lean.Meta.Canonicalizer | Lean.Meta.Canonicalizer.State → ℕ | false |
ProfiniteAddGrp.hom_ext_iff | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {A B : ProfiniteAddGrp.{u}} {f g : A ⟶ B}, f = g ↔ ProfiniteAddGrp.Hom.hom f = ProfiniteAddGrp.Hom.hom g | true |
CategoryTheory.Sieve.ofTwoArrows | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → {U V X : C} → (U ⟶ X) → (V ⟶ X) → CategoryTheory.Sieve X | true |
TemperedDistribution.instFourierTransform._proof_2 | Mathlib.Analysis.Distribution.TemperedDistribution | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
[inst_3 : MeasurableSpace E] [inst_4 : BorelSpace E], FourierAdd (SchwartzMap E ℂ) (SchwartzMap E ℂ) | false |
AlgebraicIndependent.map' | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {ι : Type u} {R : Type u_2} {A : Type v} {A' : Type v'} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : CommRing A'] [inst_3 : Algebra R A] [inst_4 : Algebra R A'],
AlgebraicIndependent R x → ∀ {f : A →ₐ[R] A'}, Function.Injective ⇑f → AlgebraicIndependent R (⇑f ∘ x) | true |
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.counit | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} →
CategoryTheory.Adjunction.CoreHomEquivUnitCounit F G → (G.comp F ⟶ CategoryTheory.Functor.id D) | true |
Associates.mk_out | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : IsCancelMulZero α] [inst_2 : NormalizationMonoid α]
(a : Associates α), Associates.mk a.out = a | true |
_private.Init.Data.UInt.Lemmas.0.UInt32.toUSize_sub._simp_1_1 | Init.Data.UInt.Lemmas | ∀ (a : UInt32) (b : USize), (a.toUSize = b % 4294967296) = (a = b.toUInt32) | false |
Quiver.Hom.comp_toLoc | Mathlib.CategoryTheory.Bicategory.LocallyDiscrete | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] {a b c : C} (f : a ⟶ b) (g : b ⟶ c),
(CategoryTheory.CategoryStruct.comp f g).toLoc = CategoryTheory.CategoryStruct.comp f.toLoc g.toLoc | true |
Mathlib.Meta.NormNum.isInt_zpow_neg | Mathlib.Tactic.NormNum.Pow | ∀ {α : Type u_1} [inst : DivisionRing α] {a : α} {b : ℤ} {nb ne : ℕ},
Mathlib.Meta.NormNum.IsInt b (Int.negOfNat nb) →
Mathlib.Meta.NormNum.IsInt (a ^ nb)⁻¹ (Int.negOfNat ne) → Mathlib.Meta.NormNum.IsInt (a ^ b) (Int.negOfNat ne) | true |
SupBotHom.dual._proof_1 | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Max α] [inst_1 : Bot α] [inst_2 : Max β] [inst_3 : Bot β],
Function.LeftInverse (fun f => { toSupHom := SupHom.dual.symm f.toInfHom, map_bot' := ⋯ }) fun f =>
{ toInfHom := SupHom.dual f.toSupHom, map_top' := ⋯ } | false |
CategoryTheory.Abelian.SpectralObject.isZero_H_obj_of_isIso | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j : ι} (f : i ⟶ j),
CategoryTheory.IsIso f → ∀ (n : ℤ), CategoryTheory.Limits.IsZero ((X.H n).obj (CategoryTheory.ComposableArrows.mk₁ f)) | true |
_private.Mathlib.RingTheory.ReesAlgebra.0.reesAlgebra.monomial_mem._simp_1_2 | Mathlib.RingTheory.ReesAlgebra | ∀ {a b : Prop}, (¬a ∨ b) = (a → b) | false |
Int.mul_tdiv_self | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), b * a.tdiv b = a - a.tmod b | true |
Descriptive.Tree.mem_pullSub_self | Mathlib.SetTheory.Descriptive.Tree | ∀ {A : Type u_1} {T : ↥(Descriptive.tree A)} {x : List A}, x ∈ Descriptive.Tree.pullSub T x ↔ [] ∈ T | true |
CategoryTheory.Sheaf.instMonoidalFunctorOppositePresheafToSheaf._proof_7 | Mathlib.CategoryTheory.Sites.Monoidal | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] (J : CategoryTheory.GrothendieckTopology C)
(A : Type u_4) [inst_1 : CategoryTheory.Category.{u_2, u_4} A] [inst_2 : CategoryTheory.MonoidalCategory A]
[inst_3 : J.W.IsMonoidal] [inst_4 : CategoryTheory.HasWeakSheafify J A],
autoParam
(∀ (X Y Z : CategoryTheory.Functor Cᵒᵖ A),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.Sheaf.instMonoidalFunctorOppositePresheafToSheaf._aux_3 J A X Y)
((CategoryTheory.presheafToSheaf J A).obj Z))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Sheaf.instMonoidalFunctorOppositePresheafToSheaf._aux_3 J A
(CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) Z)
((CategoryTheory.presheafToSheaf J A).map (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator ((CategoryTheory.presheafToSheaf J A).obj X)
((CategoryTheory.presheafToSheaf J A).obj Y) ((CategoryTheory.presheafToSheaf J A).obj Z)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((CategoryTheory.presheafToSheaf J A).obj X)
(CategoryTheory.Sheaf.instMonoidalFunctorOppositePresheafToSheaf._aux_3 J A Y Z))
(CategoryTheory.Sheaf.instMonoidalFunctorOppositePresheafToSheaf._aux_3 J A X
(CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z))))
CategoryTheory.Functor.LaxMonoidal.associativity._autoParam | false |
CategoryTheory.Equivalence.asNatTrans_mkHom | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{e f : C ≌ D} (η : e ⟶ f), CategoryTheory.Equivalence.asNatTrans (CategoryTheory.Equivalence.mkHom η) = η | true |
Batteries.RBNode.ins.eq_def | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} (cmp : α → α → Ordering) (x : α) (x_1 : Batteries.RBNode α),
Batteries.RBNode.ins cmp x x_1 =
match x_1 with
| Batteries.RBNode.nil => Batteries.RBNode.node Batteries.RBColor.red Batteries.RBNode.nil x Batteries.RBNode.nil
| Batteries.RBNode.node Batteries.RBColor.red a y b =>
match cmp x y with
| Ordering.lt => Batteries.RBNode.node Batteries.RBColor.red (Batteries.RBNode.ins cmp x a) y b
| Ordering.gt => Batteries.RBNode.node Batteries.RBColor.red a y (Batteries.RBNode.ins cmp x b)
| Ordering.eq => Batteries.RBNode.node Batteries.RBColor.red a x b
| Batteries.RBNode.node Batteries.RBColor.black a y b =>
match cmp x y with
| Ordering.lt => (Batteries.RBNode.ins cmp x a).balance1 y b
| Ordering.gt => a.balance2 y (Batteries.RBNode.ins cmp x b)
| Ordering.eq => Batteries.RBNode.node Batteries.RBColor.black a x b | true |
Subgroup.instSetLike | Mathlib.Algebra.Group.Subgroup.Defs | {G : Type u_1} → [inst : Group G] → SetLike (Subgroup G) G | true |
_private.Init.Data.Rat.Lemmas.0.Rat.eq_iff_mul_eq_mul._simp_1_1 | Init.Data.Rat.Lemmas | ∀ {a b : ℚ}, (a = b) = (a ≤ b ∧ b ≤ a) | false |
FractionalIdeal.dual_involutive | Mathlib.RingTheory.DedekindDomain.Different | ∀ {A : Type u_1} {K : Type u_2} {L : Type u} {B : Type u_3} [inst : CommRing A] [inst_1 : Field K] [inst_2 : CommRing B]
[inst_3 : Field L] [inst_4 : Algebra A K] [inst_5 : Algebra B L] [inst_6 : Algebra A B] [inst_7 : Algebra K L]
[inst_8 : Algebra A L] [inst_9 : IsScalarTower A K L] [inst_10 : IsScalarTower A B L] [inst_11 : IsDomain A]
[inst_12 : IsFractionRing A K] [inst_13 : FiniteDimensional K L] [inst_14 : Algebra.IsSeparable K L]
[inst_15 : IsIntegralClosure B A L] [inst_16 : IsFractionRing B L] [inst_17 : IsIntegrallyClosed A]
[inst_18 : IsDedekindDomain B], Function.Involutive (FractionalIdeal.dual A K) | true |
Ideal.spanNorm_eq_bot_iff._simp_1 | Mathlib.RingTheory.Ideal.Norm.RelNorm | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] {S : Type u_3} [inst_2 : CommRing S] [inst_3 : IsDomain S]
[inst_4 : IsIntegrallyClosed R] [inst_5 : IsIntegrallyClosed S] [inst_6 : Algebra R S] [inst_7 : Module.Finite R S]
[inst_8 : Module.IsTorsionFree R S] {I : Ideal S}, (Ideal.spanNorm R I = ⊥) = (I = ⊥) | false |
Fin.OrderEmbedding.instInhabitedOrderEmbeddingNat | Mathlib.Order.Fin.Basic | {n : ℕ} → Inhabited (Fin n ↪o ℕ) | true |
_private.Lean.Meta.Match.MatchEqs.0.Lean.Meta.Match.getEquationsForImpl.match_9 | Lean.Meta.Match.MatchEqs | (motive :
MProd (Array (Array Bool))
(MProd (Array Lean.Name) (MProd ℕ (MProd (Array Lean.Expr) (Array Lean.Meta.Match.AltParamInfo)))) →
Sort u_1) →
(r :
MProd (Array (Array Bool))
(MProd (Array Lean.Name) (MProd ℕ (MProd (Array Lean.Expr) (Array Lean.Meta.Match.AltParamInfo))))) →
((altArgMasks : Array (Array Bool)) →
(eqnNames : Array Lean.Name) →
(idx : ℕ) →
(notAlts : Array Lean.Expr) →
(splitterAltInfos : Array Lean.Meta.Match.AltParamInfo) →
motive ⟨altArgMasks, eqnNames, idx, notAlts, splitterAltInfos⟩) →
motive r | false |
SaturatedAddSubmonoid.instCompleteLattice | Mathlib.Algebra.Group.Submonoid.Saturation | (M : Type u_1) → [inst : AddZeroClass M] → CompleteLattice (SaturatedAddSubmonoid M) | true |
Std.ExtTreeMap.getKey!_maxKey | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {he : t ≠ ∅}, t.getKey! (t.maxKey he) = t.maxKey he | true |
_private.Mathlib.Combinatorics.Additive.AP.Three.Behrend.0.Behrend.map_succ._simp_1_3 | Mathlib.Combinatorics.Additive.AP.Three.Behrend | ∀ {ι : Type u_1} {R : Type u_4} [inst : NonUnitalNonAssocSemiring R] (s : Finset ι) (f : ι → R) (a : R),
∑ i ∈ s, f i * a = (∑ i ∈ s, f i) * a | false |
smoothSheafCommRing.ι_evalHom_assoc | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {EM : Type u_2} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_3} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_4} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_5} [inst_6 : TopologicalSpace H]
(I : ModelWithCorners 𝕜 E H) (M : Type u) [inst_7 : TopologicalSpace M] [inst_8 : ChartedSpace HM M] (R : Type u)
[inst_9 : TopologicalSpace R] [inst_10 : ChartedSpace H R] [inst_11 : CommRing R] [inst_12 : ContMDiffRing I (↑⊤) R]
(x : ↑(TopCat.of M)) (U : (TopologicalSpace.OpenNhds x)ᵒᵖ) {Z : CommRingCat} (h : CommRingCat.of R ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.colimit.ι
((TopologicalSpace.OpenNhds.inclusion x).op.comp (smoothSheafCommRing IM I M R).presheaf) U)
(CategoryTheory.CategoryStruct.comp (smoothSheafCommRing.evalHom IM I M R x) h) =
CategoryTheory.CategoryStruct.comp (smoothSheafCommRing.evalAt IM I M R x (Opposite.unop U)) h | true |
CoxeterMatrix.reindexGroupEquiv_symm_apply_simple | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} {B' : Type u_2} (M : CoxeterMatrix B) (e : B ≃ B') (i : B),
(M.reindexGroupEquiv e).symm (M.simple i) = (CoxeterMatrix.reindex e M).simple (e i) | true |
LinearMap.exists_eq_smul_id_of_forall_notLinearIndependent | Mathlib.LinearAlgebra.Center | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [IsDomain R] [inst_2 : AddCommGroup V] [inst_3 : Module R V]
[Module.Free R V] {f : V →ₗ[R] V}, (∀ (v : V), ¬LinearIndependent R ![v, f v]) → ∃ a, f = a • 1 | true |
_private.Mathlib.SetTheory.Ordinal.FixedPointApproximants.0.OrdinalApprox.lfpApprox_ord_mem_fixedPoint.match_1_1 | Mathlib.SetTheory.Ordinal.FixedPointApproximants | ∀ {α : Type u_1} [inst : CompleteLattice α] (f : α →o α) (x : α)
(motive :
(∃ a < (Order.succ (Cardinal.mk α)).ord,
∃ b < (Order.succ (Cardinal.mk α)).ord, a ≠ b ∧ OrdinalApprox.lfpApprox f x a = OrdinalApprox.lfpApprox f x b) →
Prop)
(x_1 :
∃ a < (Order.succ (Cardinal.mk α)).ord,
∃ b < (Order.succ (Cardinal.mk α)).ord, a ≠ b ∧ OrdinalApprox.lfpApprox f x a = OrdinalApprox.lfpApprox f x b),
(∀ (a : Ordinal.{u_1}) (h_a : a < (Order.succ (Cardinal.mk α)).ord) (b : Ordinal.{u_1})
(h_b : b < (Order.succ (Cardinal.mk α)).ord) (h_nab : a ≠ b)
(h_fab : OrdinalApprox.lfpApprox f x a = OrdinalApprox.lfpApprox f x b), motive ⋯) →
motive x_1 | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.