name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.DHashMap.Internal.Raw₀.Const.get!_insertMany_list_of_mem | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α] [inst_4 : Inhabited β],
(↑m).WF →
∀ {l : List (α × β)} {k k' : α},
(k == k') = true →
∀ {v : β},
List.Pairwise (fun a b => (a.1 == b.1) = false) l →
(k, v) ∈ l →
Std.DHashMap.Internal.Raw₀.Const.get! (↑(Std.DHashMap.Internal.Raw₀.Const.insertMany m l)) k' = v | true |
Ideal.Factors.isScalarTower | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u} [inst : CommRing R] {S : Type v} [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : IsDedekindDomain S] (P : ↥(UniqueFactorizationMonoid.factors (Ideal.map (algebraMap R S) p)).toFinset),
IsScalarTower R (R ⧸ p) (S ⧸ ↑P) | true |
CategoryTheory.CommComon.id_hom | Mathlib.CategoryTheory.Monoidal.CommComon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommComon C),
(CategoryTheory.CategoryStruct.id A).hom.hom = CategoryTheory.CategoryStruct.id A.X | true |
CategoryTheory.Abelian.SpectralObject.dHomologyIso._proof_16 | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ (n₃ n₄ : ℤ), autoParam (n₃ + 1 = n₄) CategoryTheory.Abelian.SpectralObject.dHomologyIso._auto_7 → n₃ + 1 = n₄ | false |
AddMonoidAlgebra.add_divOf | Mathlib.Algebra.MonoidAlgebra.Division | ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : AddCommMonoid G] [inst_2 : IsCancelAdd G]
(x y : AddMonoidAlgebra k G) (g : G), (x + y).divOf g = x.divOf g + y.divOf g | true |
Module.End.hasGenEigenvalue_iff | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R} {k : ℕ}, f.HasGenEigenvalue μ k ↔ (f.genEigenspace μ) ↑k ≠ ⊥ | true |
monotone_or | Mathlib.Order.BoundedOrder.Monotone | ∀ {α : Type u} [inst : Preorder α] {p q : α → Prop}, Monotone p → Monotone q → Monotone fun x => p x ∨ q x | true |
AddHom.codRestrict._proof_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_3} {N : Type u_1} {σ : Type u_2} [inst : Add M] [inst_1 : Add N] [inst_2 : SetLike σ N] (f : M →ₙ+ N)
(S : σ), (∀ (x : M), f x ∈ S) → ∀ (x y : M), f (x + y) ∈ S | false |
BoundedContinuousFunction.toContinuousMapMonoidHom.eq_1 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ (α : Type u) (R : Type u_2) [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace R] [inst_2 : Monoid R]
[inst_3 : BoundedMul R] [inst_4 : ContinuousMul R],
BoundedContinuousFunction.toContinuousMapMonoidHom α R =
{ toFun := BoundedContinuousFunction.toContinuousMap, map_one' := ⋯, map_mul' := ⋯ } | true |
GradedTensorProduct.includeLeftRingHom._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_3} {ι : Type u_4} {A : Type u_1} {B : Type u_2} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ℬ]
[inst_9 : Module ι (Additive ℤˣ)] (a₁ a₂ : A), (a₁ * a₂) ᵍ⊗ₜ[R] 1 = a₁ ᵍ⊗ₜ[R] 1 * a₂ ᵍ⊗ₜ[R] 1 | false |
Path.truncate._proof_4 | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {a b : X} (γ : Path a b) (t₀ t₁ : ℝ),
Continuous (⇑γ.extend ∘ fun s => min (max (↑s) t₀) t₁) | false |
List.destutter | Mathlib.Data.List.Defs | {α : Type u_1} → (R : α → α → Prop) → [DecidableRel R] → List α → List α | true |
SimpleGraph.Reachable.dist_triangle_left | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V}, G.Reachable u v → ∀ (w : V), G.dist u w ≤ G.dist u v + G.dist v w | true |
_private.Mathlib.Order.LiminfLimsup.0.Filter.limsSup_principal_eq_csSup._simp_1_2 | Mathlib.Order.LiminfLimsup | ∀ {α : Type u} {a : Set α} {p : α → Prop}, (∀ᶠ (x : α) in Filter.principal a, p x) = ∀ x ∈ a, p x | false |
MeasureTheory.AEEqFun.compQuasiMeasurePreserving._proof_2 | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_3} {β : Type u_1} {γ : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_1 : TopologicalSpace γ] [inst_2 : MeasurableSpace β] {ν : MeasureTheory.Measure β} (f : α → β)
(hf : MeasureTheory.Measure.QuasiMeasurePreserving f μ ν) (x x_1 : { f // MeasureTheory.AEStronglyMeasurable f ν }),
(MeasureTheory.Measure.aeEqSetoid γ ν) x x_1 →
MeasureTheory.AEEqFun.mk (↑x ∘ f) ⋯ = MeasureTheory.AEEqFun.mk (↑x_1 ∘ f) ⋯ | false |
Module.Finite.quotient | Mathlib.RingTheory.Finiteness.Basic | ∀ (R : Type u_6) {A : Type u_7} {M : Type u_8} [inst : Semiring R] [inst_1 : AddCommGroup M] [inst_2 : Ring A]
[inst_3 : Module A M] [inst_4 : Module R M] [inst_5 : SMul R A] [inst_6 : IsScalarTower R A M] [Module.Finite R M]
(N : Submodule A M), Module.Finite R (M ⧸ N) | true |
Homeomorph.coe_inv | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : InvolutiveInv G] [inst_2 : ContinuousInv G],
⇑(Homeomorph.inv G) = Inv.inv | true |
WeierstrassCurve.integralModel_b₂_eq | Mathlib.AlgebraicGeometry.EllipticCurve.Reduction | ∀ (R : Type u_1) [inst : CommRing R] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra R K] (W : WeierstrassCurve K)
[hW : WeierstrassCurve.IsIntegral R W], (algebraMap R K) (WeierstrassCurve.integralModel R W).b₂ = W.b₂ | true |
_private.Lean.Data.PersistentArray.0.Lean.PersistentArray.forInAux.match_5 | Lean.Data.PersistentArray | {α : Type u_1} →
(motive : Lean.PersistentArrayNode α → Sort u_2) →
(n : Lean.PersistentArrayNode α) →
((vs : Array α) → motive (Lean.PersistentArrayNode.leaf vs)) →
((cs : Array (Lean.PersistentArrayNode α)) → motive (Lean.PersistentArrayNode.node cs)) → motive n | false |
Lean.Grind.CommRing.Mon.denote.eq_2 | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.Semiring α] (ctx : Lean.Grind.CommRing.Context α) (p : Lean.Grind.CommRing.Power)
(m : Lean.Grind.CommRing.Mon),
Lean.Grind.CommRing.Mon.denote ctx (Lean.Grind.CommRing.Mon.mult p m) =
Lean.Grind.CommRing.Power.denote ctx p * Lean.Grind.CommRing.Mon.denote ctx m | true |
ProjectiveSpectrum.homogeneousIdeal_le_vanishingIdeal_zeroLocus | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] (I : HomogeneousIdeal 𝒜),
I ≤ ProjectiveSpectrum.vanishingIdeal (ProjectiveSpectrum.zeroLocus 𝒜 ↑I) | true |
CategoryTheory.Bicategory.LanLift.CommuteWith.isKan.congr_simp | Mathlib.CategoryTheory.Bicategory.Kan.HasKan | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : b ⟶ a) (g : c ⟶ a)
[inst_1 : CategoryTheory.Bicategory.HasLeftKanLift f g] {x : B} (h : x ⟶ c)
[inst_2 : CategoryTheory.Bicategory.LanLift.CommuteWith f g h],
CategoryTheory.Bicategory.LanLift.CommuteWith.isKan f g h = CategoryTheory.Bicategory.LanLift.CommuteWith.isKan f g h | true |
_private.Mathlib.Data.Finset.Max.0.Finset.min'_lt_max'_of_card._proof_1 | Mathlib.Data.Finset.Max | ∀ {α : Type u_1} (s : Finset α), 1 < s.card → 0 < s.card | false |
SimpleGraph.card_commonNeighbors_le_degree_left | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : Fintype V] [inst_1 : DecidableRel G.Adj] (v w : V),
Fintype.card ↑(G.commonNeighbors v w) ≤ G.degree v | true |
Cardinal | Mathlib.SetTheory.Cardinal.Defs | Type (u + 1) | true |
UniformContinuousConstVAdd.mk | Mathlib.Topology.Algebra.UniformMulAction | ∀ {M : Type v} {X : Type x} [inst : UniformSpace X] [inst_1 : VAdd M X],
(∀ (c : M), UniformContinuous fun x => c +ᵥ x) → UniformContinuousConstVAdd M X | true |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.preprocessHypothesis._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Intro | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Lean.Meta.ArgsPacker.0.Lean.Meta.ArgsPacker.Mutual.mkCodomain.go._unsafe_rec | Lean.Meta.ArgsPacker | Array Lean.Expr → Lean.Level → Lean.Expr → ℕ → Lean.MetaM Lean.Expr | false |
Array.le_findIdx_of_not | Init.Data.Array.Find | ∀ {α : Type u_1} {p : α → Bool} {xs : Array α} {i : ℕ} (h : i < xs.size),
(∀ (j : ℕ) (hji : j < i), p xs[j] = false) → i ≤ Array.findIdx p xs | true |
Topology.scottHausdorff._proof_7 | Mathlib.Topology.Order.ScottTopology | ∀ (α : Type u_1) (D : Set (Set α)) [inst : Preorder α] (s t : Set α),
(∀ ⦃d : Set α⦄,
d ∈ D →
d.Nonempty → DirectedOn (fun x1 x2 => x1 ≤ x2) d → ∀ ⦃a : α⦄, IsLUB d a → a ∈ s → ∃ b ∈ d, Set.Ici b ∩ d ⊆ s) →
(∀ ⦃d : Set α⦄,
d ∈ D →
d.Nonempty →
DirectedOn (fun x1 x2 => x1 ≤ x2) d → ∀ ⦃a : α⦄, IsLUB d a → a ∈ t → ∃ b ∈ d, Set.Ici b ∩ d ⊆ t) →
∀ d ∈ D,
d.Nonempty →
DirectedOn (fun x1 x2 => x1 ≤ x2) d → ∀ (a : α), IsLUB d a → a ∈ s ∩ t → ∃ b ∈ d, Set.Ici b ∩ d ⊆ s ∩ t | false |
OrderDual.instCommMonoid._proof_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [h : CommMonoid α] (a b : αᵒᵈ), a * b = b * a | false |
Filter.TendstoCofinite.finite_preimage | Mathlib.Order.Filter.TendstoCofinite | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) [Filter.TendstoCofinite f] {s : Set β}, s.Finite → (f ⁻¹' s).Finite | true |
CategoryTheory.Comma.colimitAuxiliaryCocone | Mathlib.CategoryTheory.Limits.Comma | {J : Type w} →
[inst : CategoryTheory.Category.{w', w} J] →
{A : Type u₁} →
[inst_1 : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_3 : CategoryTheory.Category.{v₃, u₃} T] →
{L : CategoryTheory.Functor A T} →
{R : CategoryTheory.Functor B T} →
(F : CategoryTheory.Functor J (CategoryTheory.Comma L R)) →
CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.snd L R)) →
CategoryTheory.Limits.Cocone ((F.comp (CategoryTheory.Comma.fst L R)).comp L) | true |
Lean.Meta.SimpTheorems.addLetDeclToUnfold | Lean.Meta.Tactic.Simp.SimpTheorems | Lean.Meta.SimpTheorems → Lean.FVarId → Lean.Meta.SimpTheorems | true |
Valued.mk.noConfusion | Mathlib.Topology.Algebra.Valued.ValuationTopology | {R : Type u} →
{inst : Ring R} →
{Γ₀ : outParam (Type v)} →
{inst_1 : LinearOrderedCommGroupWithZero Γ₀} →
{P : Sort u_1} →
{toUniformSpace : UniformSpace R} →
{toIsUniformAddGroup : IsUniformAddGroup R} →
{v : Valuation R Γ₀} →
{is_topological_valuation : ∀ (s : Set R), s ∈ nhds 0 ↔ ∃ γ, {x | v.restrict x < ↑γ} ⊆ s} →
{toUniformSpace' : UniformSpace R} →
{toIsUniformAddGroup' : IsUniformAddGroup R} →
{v' : Valuation R Γ₀} →
{is_topological_valuation' : ∀ (s : Set R), s ∈ nhds 0 ↔ ∃ γ, {x | v'.restrict x < ↑γ} ⊆ s} →
{ toUniformSpace := toUniformSpace, toIsUniformAddGroup := toIsUniformAddGroup, v := v,
is_topological_valuation := is_topological_valuation } =
{ toUniformSpace := toUniformSpace', toIsUniformAddGroup := toIsUniformAddGroup', v := v',
is_topological_valuation := is_topological_valuation' } →
(toUniformSpace ≍ toUniformSpace' → v ≍ v' → P) → P | false |
_private.Mathlib.MeasureTheory.Measure.Haar.OfBasis.0.parallelepiped_single._simp_1_2 | Mathlib.MeasureTheory.Measure.Haar.OfBasis | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) | false |
GeneralSchauderBasis.mk | Mathlib.Analysis.Normed.Module.Bases | {β : Type u_3} →
{𝕜 : Type u_4} →
{X : Type u_5} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NormedAddCommGroup X] →
[inst_2 : NormedSpace 𝕜 X] →
{L : SummationFilter β} →
(basis : β → X) →
(coord : β → StrongDual 𝕜 X) →
(∀ (i j : β), (coord i) (basis j) = Pi.single j 1 i) →
(∀ (x : X), HasSum (fun i => (coord i) x • basis i) x L) → GeneralSchauderBasis β 𝕜 X L | true |
AddEquiv.op_symm_apply_symm_apply | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {α : Type u_3} {β : Type u_4} [inst : Add α] [inst_1 : Add β] (f : αᵃᵒᵖ ≃+ βᵃᵒᵖ) (a : β),
(AddEquiv.op.symm f).symm a = (AddOpposite.unop ∘ ⇑f.symm ∘ AddOpposite.op) a | true |
ContinuousLinearMap.sSup_unitClosedBall_eq_norm | Mathlib.Analysis.Normed.Operator.NNNorm | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : NormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : DenselyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [RingHomIsometric σ₁₂] (f : E →SL[σ₁₂] F),
sSup ((fun x => ‖f x‖) '' Metric.closedBall 0 1) = ‖f‖ | true |
Std.Tactic.BVDecide.BVExpr.bitblast._proof_17 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (w : ℕ) (eaig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit)
(evec : eaig.RefVec w),
aig.decls.size ≤ { aig := eaig, vec := evec }.aig.decls.size →
aig.decls.size ≤ (Std.Tactic.BVDecide.BVExpr.bitblast.blastClz eaig evec).aig.decls.size | false |
MeasureTheory.OuterMeasure.ofFunction | Mathlib.MeasureTheory.OuterMeasure.OfFunction | {α : Type u_1} → (m : Set α → ENNReal) → m ∅ = 0 → MeasureTheory.OuterMeasure α | true |
ZeroAtInftyContinuousMap.instNonUnitalCommCStarAlgebra | Mathlib.Analysis.CStarAlgebra.ContinuousMap | {α : Type u_1} →
{A : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : NonUnitalCommCStarAlgebra A] → NonUnitalCommCStarAlgebra (ZeroAtInftyContinuousMap α A) | true |
String.data_push | Init.Data.String.Basic | ∀ {s : String} (c : Char), (s.push c).toList = s.toList ++ [c] | true |
BoundedVariationOn.exists_tendsto_atBot | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : PseudoEMetricSpace E] [CompleteSpace E]
[hE : Nonempty E] {f : α → E} {s : Set α},
BoundedVariationOn f s → ∃ l, Filter.Tendsto f (Filter.principal s ⊓ Filter.atBot) (nhds l) | true |
IsDedekindDomain.primesOverEquivPrimesOver | Mathlib.RingTheory.Localization.AtPrime.Extension | {R : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
(p : Ideal R) →
[inst_3 : p.IsPrime] →
(Rₚ : Type u_3) →
[inst_4 : CommRing Rₚ] →
[inst_5 : Algebra R Rₚ] →
[IsLocalization.AtPrime Rₚ p] →
[inst_7 : IsLocalRing Rₚ] →
(Sₚ : Type u_4) →
[inst_8 : CommRing Sₚ] →
[inst_9 : Algebra S Sₚ] →
[IsLocalization (Algebra.algebraMapSubmonoid S p.primeCompl) Sₚ] →
[inst_11 : Algebra Rₚ Sₚ] →
[IsDomain R] →
[IsDedekindDomain S] →
[Module.IsTorsionFree R S] →
[inst_15 : Algebra R Sₚ] →
[IsScalarTower R S Sₚ] →
[IsScalarTower R Rₚ Sₚ] →
p ≠ ⊥ →
↑(p.primesOver S) ≃o ↑((IsLocalRing.maximalIdeal Rₚ).primesOver Sₚ) | true |
CategoryTheory.Adjunction.sheafPushforwardContinuous._proof_5 | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_5}
[inst_1 : CategoryTheory.Category.{u_6, u_5} D] {E : Type u_3} [inst_2 : CategoryTheory.Category.{u_2, u_3} E]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G)
(J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [inst_3 : F.IsContinuous J K]
[inst_4 : G.IsContinuous K J] (P : CategoryTheory.Sheaf K E),
CategoryTheory.CategoryStruct.comp
((F.sheafPushforwardContinuous E J K).map
({ app := fun P => { hom := (CategoryTheory.Adjunction.whiskerLeft E adj.op).unit.app P.obj },
naturality := ⋯ }.app
P))
({ app := fun P => { hom := (CategoryTheory.Adjunction.whiskerLeft E adj.op).counit.app P.obj },
naturality := ⋯ }.app
((F.sheafPushforwardContinuous E J K).obj P)) =
CategoryTheory.CategoryStruct.id ((F.sheafPushforwardContinuous E J K).obj P) | false |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.PropagateEq.0.Lean.Meta.Grind.Arith.Linear.updateOccsAt | Lean.Meta.Tactic.Grind.Arith.Linear.PropagateEq | ℕ →
Lean.Grind.Linarith.Var →
Lean.Meta.Grind.Arith.Linear.EqCnstr → Lean.Grind.Linarith.Var → Lean.Meta.Grind.Arith.Linear.LinearM Unit | true |
_private.Mathlib.Algebra.Group.Nat.Even.0.Nat.not_even_iff._proof_1_1 | Mathlib.Algebra.Group.Nat.Even | ∀ {n : ℕ}, ¬Even n ↔ n % 2 = 1 | false |
Lean.KeyedDeclsAttribute.mk.noConfusion | Lean.KeyedDeclsAttribute | {γ : Type} →
{P : Sort u} →
{defn : Lean.KeyedDeclsAttribute.Def γ} →
{tableRef : IO.Ref (Lean.KeyedDeclsAttribute.Table γ)} →
{ext : Lean.KeyedDeclsAttribute.Extension γ} →
{defn' : Lean.KeyedDeclsAttribute.Def γ} →
{tableRef' : IO.Ref (Lean.KeyedDeclsAttribute.Table γ)} →
{ext' : Lean.KeyedDeclsAttribute.Extension γ} →
{ defn := defn, tableRef := tableRef, ext := ext } =
{ defn := defn', tableRef := tableRef', ext := ext' } →
(defn ≍ defn' → tableRef ≍ tableRef' → ext ≍ ext' → P) → P | false |
Int16.toBitVec | Init.Data.SInt.Basic | Int16 → BitVec 16 | true |
Int.emod_add_ediv_mul | Init.Data.Int.DivMod.Bootstrap | ∀ (a b : ℤ), a % b + a / b * b = a | true |
RingHom.finitePresentation_respectsIso | Mathlib.RingTheory.RingHom.FinitePresentation | RingHom.RespectsIso @RingHom.FinitePresentation | true |
Topology.IsQuotientMap.of_comp | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
[inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z],
Continuous f → Continuous g → Topology.IsQuotientMap (g ∘ f) → Topology.IsQuotientMap g | true |
NonAssocRing.ctorIdx | Mathlib.Algebra.Ring.Defs | {α : Type u_1} → NonAssocRing α → ℕ | false |
CategoryTheory.uliftYonedaEquiv_symm_comp_assoc | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {F G : CategoryTheory.Functor Cᵒᵖ (Type (max w v₁))}
{X : Cᵒᵖ} (x : F.obj X) (f : F ⟶ G) {Z : CategoryTheory.Functor Cᵒᵖ (Type (max w v₁))} (h : G ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.uliftYonedaEquiv.symm x) (CategoryTheory.CategoryStruct.comp f h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.uliftYonedaEquiv.symm (f.app (Opposite.op (Opposite.unop X)) x))
h | true |
IsRCLikeNormedField.casesOn | Mathlib.Analysis.RCLike.Basic | {𝕜 : Type u_3} →
[hk : NormedField 𝕜] →
{motive : IsRCLikeNormedField 𝕜 → Sort u} →
(t : IsRCLikeNormedField 𝕜) → ((out : ∃ h, hk = h.toNormedField) → motive ⋯) → motive t | false |
Polynomial.eventually_atBot_not_isRoot | Mathlib.Analysis.Polynomial.Basic | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] (P : Polynomial 𝕜),
P ≠ 0 → ∀ᶠ (x : 𝕜) in Filter.atBot, ¬P.IsRoot x | true |
Finsupp.semilatticeInf._proof_4 | Mathlib.Order.Preorder.Finsupp | ∀ {ι : Type u_1} {M : Type u_2} [inst : Zero M] [inst_1 : SemilatticeInf M] (_f _g _i : ι →₀ M),
_f ≤ _g → _f ≤ _i → ∀ (s : ι), _f s ≤ _g s ⊓ _i s | false |
Std.Tactic.BVDecide.Normalize.UInt16.toBitVec_ite | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {c : Prop} {t e : UInt16} [inst : Decidable c], (if c then t else e).toBitVec = if c then t.toBitVec else e.toBitVec | true |
hasFDerivWithinAt_closure_of_tendsto_fderiv | Mathlib.Analysis.Calculus.FDeriv.Extend | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {F : Type u_2} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {f : E → F} {s : Set E} {x : E} {f' : E →L[ℝ] F},
DifferentiableOn ℝ f s →
Convex ℝ s →
IsOpen s →
(∀ y ∈ closure s, ContinuousWithinAt f s y) →
Filter.Tendsto (fun y => fderiv ℝ f y) (nhdsWithin x s) (nhds f') → HasFDerivWithinAt f f' (closure s) x | true |
Ideal.sInf_isPrime_of_isChain | Mathlib.RingTheory.Ideal.Maximal | ∀ {α : Type u} [inst : Semiring α] {s : Set (Ideal α)},
s.Nonempty → IsChain (fun x1 x2 => x1 ≤ x2) s → (∀ p ∈ s, p.IsPrime) → (sInf s).IsPrime | true |
CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms.functorToMonoOver._proof_4 | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.EnoughInjectives | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {G : C} [inst_1 : CategoryTheory.Abelian C]
(hG : CategoryTheory.IsSeparator G) {X : C} [inst_2 : CategoryTheory.IsGrothendieckAbelian.{u_3, u_1, u_2} C]
(A₀ : CategoryTheory.Subobject X) (J : Type u_3) [inst_3 : LinearOrder J] [inst_4 : OrderBot J] [inst_5 : SuccOrder J]
[inst_6 : WellFoundedLT J] (X_1 : J),
CategoryTheory.MonoOver.homMk
((transfiniteIterate (CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms.largerSubobject hG) X_1
A₀).ofLE
(transfiniteIterate (CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms.largerSubobject hG) X_1 A₀) ⋯)
⋯ =
CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoOver.mk
(transfiniteIterate (CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms.largerSubobject hG) X_1
A₀).arrow) | false |
SimpleGraph.chromaticNumber_sum | Mathlib.Combinatorics.SimpleGraph.Sum | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {H : SimpleGraph W},
(G ⊕g H).chromaticNumber = max G.chromaticNumber H.chromaticNumber | true |
Profinite.NobelingProof.Products.evalCons | Mathlib.Topology.Category.Profinite.Nobeling.Successor | ∀ {I : Type u_1} [inst : LinearOrder I] {C : Set (I → Bool)} {l : List I} {a : I}
(hla : List.IsChain (fun x1 x2 => x1 > x2) (a :: l)),
Profinite.NobelingProof.Products.eval C ⟨a :: l, hla⟩ =
Profinite.NobelingProof.e C a * Profinite.NobelingProof.Products.eval C ⟨l, ⋯⟩ | true |
_private.Batteries.Tactic.Congr.0.Batteries.Tactic._aux_Batteries_Tactic_Congr___macroRules_Batteries_Tactic_congrConfigWith_1.match_6 | Batteries.Tactic.Congr | (motive : Option (Lean.TSyntax `Lean.Parser.Tactic.config) → Sort u_1) →
(cfg : Option (Lean.TSyntax `Lean.Parser.Tactic.config)) →
(Unit → motive none) → ((cfg : Lean.TSyntax `Lean.Parser.Tactic.config) → motive (some cfg)) → motive cfg | false |
Quaternion.im_sub | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a b : Quaternion R), (a - b).im = a.im - b.im | true |
Std.Tactic.BVDecide.LRAT.Internal.instDecidableEqResult._proof_2 | Std.Tactic.BVDecide.LRAT.Internal.LRATChecker | ∀ (x y : Std.Tactic.BVDecide.LRAT.Internal.Result), ¬x.ctorIdx = y.ctorIdx → x = y → False | false |
AddMonCat.addMonoidObj.eq_1 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J AddMonCat) (j : J),
AddMonCat.addMonoidObj F j = AddMonCat.addMonoidObj._aux_1 F j | true |
Set.mulIndicator_range_comp | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : One M] {ι : Sort u_5} (f : ι → α) (g : α → M),
(Set.range f).mulIndicator g ∘ f = g ∘ f | true |
Std.Sat.AIG.mkGateCached.go_le_size | Std.Sat.AIG.CachedLemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (aig : Std.Sat.AIG α) (input : aig.BinaryInput),
aig.decls.size ≤ (Std.Sat.AIG.mkGateCached.go aig input).aig.decls.size | true |
AddSubmonoid.center.addCommMonoid'._proof_6 | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : AddZeroClass M] (a b : ↥(AddSubsemigroup.center M)), a + b = b + a | false |
Submodule.instIsOrderedAddMonoid | Mathlib.Algebra.Module.Submodule.Pointwise | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
IsOrderedAddMonoid (Submodule R M) | true |
CategoryTheory.Abelian.AbelianStruct.cokernelCofork | Mathlib.CategoryTheory.Abelian.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_2, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{X Y : C} → {f : X ⟶ Y} → CategoryTheory.Abelian.AbelianStruct f → CategoryTheory.Limits.CokernelCofork f | true |
_private.Lean.Declaration.0.Lean.instBEqReducibilityHints.beq._sparseCasesOn_2 | Lean.Declaration | {motive : Lean.ReducibilityHints → Sort u} →
(t : Lean.ReducibilityHints) →
motive Lean.ReducibilityHints.abbrev → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.Algebra.Group.Defs.0.inv_eq_of_mul | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : Group G] {a b : G}, a * b = 1 → a⁻¹ = b | true |
BddAbove.image2_bddBelow | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ] {f : α → β → γ}
{s : Set α} {t : Set β},
(∀ (b : β), Antitone (Function.swap f b)) →
(∀ (a : α), Antitone (f a)) → BddAbove s → BddAbove t → BddBelow (Set.image2 f s t) | true |
LinearMap.nondegenerate_toMatrix₂'_iff._simp_1 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {n : Type u_11} {m : Type u_12} [inst : CommRing R] [inst_1 : DecidableEq m] [inst_2 : Fintype m]
[inst_3 : DecidableEq n] [inst_4 : Fintype n] {B : (m → R) →ₗ[R] (n → R) →ₗ[R] R},
((LinearMap.toMatrix₂' R) B).Nondegenerate = B.Nondegenerate | false |
AdjoinRoot.instField._proof_13 | Mathlib.RingTheory.AdjoinRoot | ∀ {K : Type u_1} [inst : Field K], IsScalarTower ℚ K K | false |
SubfieldClass.toDivisionRing._proof_12 | Mathlib.Algebra.Field.Subfield.Defs | ∀ {K : Type u_2} [inst : DivisionRing K] (S : Type u_1) [inst_1 : SetLike S K] [h : SubfieldClass S K], ZeroMemClass S K | false |
_private.Mathlib.Topology.Separation.Hausdorff.0.T2Quotient.instT2Space._simp_2 | Mathlib.Topology.Separation.Hausdorff | ∀ {α : Sort u_1} {r : Setoid α} {x y : α}, (⟦x⟧ = ⟦y⟧) = r x y | false |
HahnEmbedding.Seed.toArchimedeanStrata | Mathlib.Algebra.Order.Module.HahnEmbedding | {K : Type u_1} →
[inst : DivisionRing K] →
[inst_1 : LinearOrder K] →
[inst_2 : IsOrderedRing K] →
[inst_3 : Archimedean K] →
{M : Type u_2} →
[inst_4 : AddCommGroup M] →
[inst_5 : LinearOrder M] →
[inst_6 : IsOrderedAddMonoid M] →
[inst_7 : Module K M] →
[inst_8 : IsOrderedModule K M] →
{R : Type u_3} →
[inst_9 : AddCommGroup R] →
[inst_10 : LinearOrder R] →
[inst_11 : Module K R] → HahnEmbedding.Seed K M R → HahnEmbedding.ArchimedeanStrata K M | true |
Rat.nnabs._proof_1 | Mathlib.Data.NNRat.Defs | ∀ (x : ℚ), 0 ≤ |x| | false |
SubAddAction.ofFixingAddSubgroup.append._proof_2 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ {α : Type u_1} {s : Set α} [Finite ↑s], Nonempty (Fin s.ncard ≃ ↑s) | false |
Subrepresentation.coe_sup._simp_1 | Mathlib.RepresentationTheory.Subrepresentation | ∀ {A : Type u_1} {G : Type u_2} {W : Type u_3} [inst : Semiring A] [inst_1 : Monoid G] [inst_2 : AddCommMonoid W]
[inst_3 : Module A W] {ρ : Representation A G W} (ρ₁ ρ₂ : Subrepresentation ρ), ↑ρ₁ + ↑ρ₂ = ↑(ρ₁ ⊔ ρ₂) | false |
IsTopologicalGroup.mulInvClosureNhd.mk | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : TopologicalSpace G] {T W : Set G} [inst_1 : Group G],
T ∈ nhds 1 → T⁻¹ = T → IsOpen T → W * T ⊆ W → IsTopologicalGroup.mulInvClosureNhd T W | true |
_private.Batteries.Data.List.Lemmas.0.List.foldrIdx_start._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_2} {α_1 : Type u_1} {i : α_1} {f : ℕ → α → α_1 → α_1} {s : ℕ},
List.foldrIdx f i [] s = List.foldrIdx (fun x => f (x + s)) i [] | false |
Matrix.eq_zero_of_forall_pow_sum_mul_pow_eq_zero | Mathlib.LinearAlgebra.Vandermonde | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} [IsDomain R] {f v : Fin n → R},
Function.Injective f → (∀ (i : Fin n), ∑ j, v j * f j ^ ↑i = 0) → v = 0 | true |
IsPurelyInseparable.algebraMap_elemReduct_eq | Mathlib.FieldTheory.PurelyInseparable.Exponent | ∀ (K : Type u_2) {L : Type u_3} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : IsPurelyInseparable K L] (a : L),
(algebraMap K L) (IsPurelyInseparable.elemReduct K a) = a ^ ringExpChar K ^ IsPurelyInseparable.elemExponent K a | true |
TopCat.Presheaf.stalkFunctor_preserves_mono | Mathlib.Topology.Sheaves.Stalks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasColimits C] {X : TopCat}
{FC : C → C → Type u_1} {CC : C → Type v} [inst_2 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)]
[instCC : CategoryTheory.ConcreteCategory C FC]
[CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] [CategoryTheory.Limits.HasLimits C]
[CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget C)] [(CategoryTheory.forget C).ReflectsIsomorphisms]
(x : ↑X), ((TopCat.Sheaf.forget C X).comp (TopCat.Presheaf.stalkFunctor C x)).PreservesMonomorphisms | true |
List.prev_eq_getElem_idxOf_pred_of_ne_head._proof_3 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α} {a : α}, a ∈ l → List.idxOf a l - 1 < l.length | false |
CategoryTheory.InjectiveResolution.ofCocomplex_d_0_1 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.EnoughInjectives C] (Z : C),
(CategoryTheory.InjectiveResolution.ofCocomplex Z).d 0 1 = CategoryTheory.Injective.d (CategoryTheory.Injective.ι Z) | true |
Mathlib.Tactic.Bicategory.Context._sizeOf_1 | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | Mathlib.Tactic.Bicategory.Context → ℕ | false |
_private.Mathlib.AlgebraicGeometry.Sites.Small.0.AlgebraicGeometry.Scheme.smallGrothendieckTopologyOfLE_eq_toGrothendieck_smallPretopology.match_1_6 | Mathlib.AlgebraicGeometry.Sites.Small | ∀ {P Q : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} (S : AlgebraicGeometry.Scheme)
[inst : P.IsStableUnderBaseChange] (X : Q.Over ⊤ S) (R : CategoryTheory.Sieve X)
(motive :
(∃ 𝒰 x,
𝒰.toPresieveOver ≤
(CategoryTheory.Sieve.functorPushforward (CategoryTheory.MorphismProperty.Over.forget Q ⊤ S) R).arrows) →
Prop)
(h :
∃ 𝒰 x,
𝒰.toPresieveOver ≤
(CategoryTheory.Sieve.functorPushforward (CategoryTheory.MorphismProperty.Over.forget Q ⊤ S) R).arrows),
(∀ (𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X.left)
(h : AlgebraicGeometry.Scheme.Cover.Over S 𝒰)
(le :
𝒰.toPresieveOver ≤
(CategoryTheory.Sieve.functorPushforward (CategoryTheory.MorphismProperty.Over.forget Q ⊤ S) R).arrows),
motive ⋯) →
motive h | false |
_private.Lean.Environment.0.Lean.Environment.instBEqRealizeConstKey.beq | Lean.Environment | Lean.Environment.RealizeConstKey✝ → Lean.Environment.RealizeConstKey✝ → Bool | true |
CategoryTheory.Limits.Cone.extendComp._proof_2 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor J C} (s : CategoryTheory.Limits.Cone F)
{X Y : C} (f : X ⟶ Y) (g : Y ⟶ s.pt) (j : J),
(s.extend (CategoryTheory.CategoryStruct.comp f g)).π.app j =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl (s.extend (CategoryTheory.CategoryStruct.comp f g)).pt).hom
(((s.extend g).extend f).π.app j) | false |
LocallyConstant.congrRight | Mathlib.Topology.LocallyConstant.Basic | {X : Type u_1} →
{Y : Type u_2} → {Z : Type u_3} → [inst : TopologicalSpace X] → Y ≃ Z → LocallyConstant X Y ≃ LocallyConstant X Z | true |
ContMDiffWithinAt.mul | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {n : WithTop ℕ∞}
{G : Type u_4} [inst_4 : Mul G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace H G] {E' : Type u_5}
[inst_7 : NormedAddCommGroup E'] [inst_8 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_9 : TopologicalSpace H']
{I' : ModelWithCorners 𝕜 E' H'} {M : Type u_7} [inst_10 : TopologicalSpace M] [inst_11 : ChartedSpace H' M]
[ContMDiffMul I n G] {f g : M → G} {s : Set M} {x : M},
ContMDiffWithinAt I' I n f s x → ContMDiffWithinAt I' I n g s x → ContMDiffWithinAt I' I n (f * g) s x | true |
CategoryTheory.Functor.Braided.toMonoidal_injective | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
(F : CategoryTheory.Functor C D),
Function.Injective (@CategoryTheory.Functor.Braided.toMonoidal C inst inst_1 inst_2 D inst_3 inst_4 inst_5 F) | true |
DyckWord.insidePart._proof_2 | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ (p : DyckWord) (h : ¬p = 0), p.take (p.firstReturn + 1) ⋯ ≠ 0 | false |
NormedAddCommGroup.toCompl._proof_1 | Mathlib.Analysis.Normed.Group.HomCompletion | ∀ {G : Type u_1} [inst : SeminormedAddCommGroup G] (v : G), ‖↑v‖ ≤ 1 * ‖v‖ | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.