name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Orthonormal.exists_hilbertBasis_extension | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[CompleteSpace E] {s : Set E}, Orthonormal 𝕜 Subtype.val → ∃ w b, s ⊆ w ∧ ⇑b = Subtype.val | true |
RootPairing.ofBilinear._proof_4 | Mathlib.LinearAlgebra.RootSystem.OfBilinear | ∀ {R : Type u_2} {M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(B : M →ₗ[R] M →ₗ[R] R) (hSB : B.IsSymm) (x : ↑{x | B.IsReflective x}),
Function.RightInverse (fun y => ⟨(Module.reflection ⋯) ↑y, ⋯⟩) fun y => ⟨(Module.reflection ⋯) ↑y, ⋯⟩ | false |
snd_himp | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : HImp α] [inst_1 : HImp β] (a b : α × β), (a ⇨ b).2 = a.2 ⇨ b.2 | true |
Bimod.AssociatorBimod.homAux._proof_1 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C]
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, u_1, u_1, u_2, u_2}
(CategoryTheory.MonoidalCategory.tensorLeft X... | false |
instFieldCyclotomicField._proof_16 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (n : ℕ) (K : Type u_1) [inst : Field K] (a b c : CyclotomicField n K), (a + b) * c = a * c + b * c | false |
AddCon.mkAddHom_apply | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} [inst : Add M] (c : AddCon M) (a : M), c.mkAddHom a = ↑a | true |
MulSemiringActionHom.comp._proof_4 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_6} [inst : Monoid M] {N : Type u_4} [inst_1 : Monoid N] {P : Type u_5} [inst_2 : Monoid P] {φ : M →* N}
{ψ : N →* P} {R : Type u_2} [inst_3 : Semiring R] [inst_4 : MulSemiringAction M R] {S : Type u_3}
[inst_5 : Semiring S] [inst_6 : MulSemiringAction N S] {T : Type u_1} [inst_7 : Semiring T]
[inst_... | false |
ContinuousMap.instNonUnitalNormedRing._proof_3 | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] {R : Type u_2} [inst_2 : NonUnitalNormedRing R]
(a : C(α, R)), 0 * a = 0 | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastVar.go_denote_eq._proof_1_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var | ∀ {w : ℕ} (curr idx : ℕ), curr < idx → ¬curr + 1 ≤ idx → False | false |
CategoryTheory.monoidalOfHasFiniteProducts.tensorObj | Mathlib.CategoryTheory.Monoidal.OfHasFiniteProducts | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasTerminal C]
[inst_2 : CategoryTheory.Limits.HasBinaryProducts C] (X Y : C),
CategoryTheory.MonoidalCategoryStruct.tensorObj X Y = (X ⨯ Y) | true |
unitInterval.tendsto_sigmoid_atBot | Mathlib.Analysis.SpecialFunctions.Sigmoid | Filter.Tendsto unitInterval.sigmoid Filter.atBot (nhds 0) | true |
CategoryTheory.GradedObject.comapEquiv._proof_1 | Mathlib.CategoryTheory.GradedObject | ∀ {β γ : Type u_1} (e : β ≃ γ), (fun i => i) = ⇑e.symm ∘ ⇑e | false |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.length_eq_match_step.match_1.eq_3 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β : Type u_1} (motive : Std.IterStep (Std.Iter β) β → Sort u_2)
(h_1 : (it' : Std.Iter β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.Iter β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.done with
| Std.IterStep.yield it' out => h... | true |
Simps.ParsedProjectionData.mk.injEq | Mathlib.Tactic.Simps.Basic | ∀ (strName : Lean.Name) (strStx : Lean.Syntax) (newName : Lean.Name) (newStx : Lean.Syntax) (isDefault isPrefix : Bool)
(expr? : Option Lean.Expr) (projNrs : Array ℕ) (isCustom : Bool) (strName_1 : Lean.Name) (strStx_1 : Lean.Syntax)
(newName_1 : Lean.Name) (newStx_1 : Lean.Syntax) (isDefault_1 isPrefix_1 : Bool) (... | true |
WeierstrassCurve.Affine.negY.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Affine R) (x y : R), W'.negY x y = -y - W'.a₁ * x - W'.a₃ | true |
Lean.Try.Config.ctorIdx | Init.Try | Lean.Try.Config → ℕ | false |
CategoryTheory.Functor.Fiber.inducedFunctor.congr_simp | Mathlib.CategoryTheory.FiberedCategory.Grothendieck | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} {S : 𝒮} {C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F F_1 : CategoryTheory.Functor C 𝒳} (e_F : F = F_1) (hF : F.comp p = (CategoryTheory.F... | true |
IsOfFinAddOrder.nsmul | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddMonoid G] {a : G} {n : ℕ}, IsOfFinAddOrder a → IsOfFinAddOrder (n • a) | true |
_private.Mathlib.Order.Nucleus.0.Nucleus.instHImp._simp_4 | Mathlib.Order.Nucleus | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∀ (a : α), b) = b | false |
_private.Mathlib.MeasureTheory.MeasurableSpace.Constructions.0.measurableAtom_eq_of_mem._simp_1_2 | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | false |
_private.Init.Data.Array.Attach.0.Array.pmapImpl.eq_1 | Init.Data.Array.Attach | ∀ {α : Type u_1} {β : Type u_2} {P : α → Prop} (f : (a : α) → P a → β) (xs : Array α) (H : ∀ a ∈ xs, P a),
Array.pmapImpl f xs H =
Array.map
(fun x =>
match x with
| ⟨x, h'⟩ => f x h')
(xs.attachWith P H) | true |
Lean.IR.initFn._@.Lean.Compiler.IR.SimpleGroundExpr.160484116._hygCtx._hyg.2 | Lean.Compiler.IR.SimpleGroundExpr | IO (Lean.EnvExtension Lean.IR.SimpleGroundExtState) | false |
MeasurableInf.measurable_const_inf._autoParam | Mathlib.MeasureTheory.Order.Lattice | Lean.Syntax | false |
IsPrimePow.ne_zero | Mathlib.Algebra.IsPrimePow | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] [NoZeroDivisors R] {n : R}, IsPrimePow n → n ≠ 0 | true |
Std.ExtTreeMap.getKey?_congr | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k k' : α},
cmp k k' = Ordering.eq → t.getKey? k = t.getKey? k' | true |
String.Slice.Pattern.Model.CharPred.instNoPrefixForwardPatternModelForallCharBool | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Bool}, String.Slice.Pattern.Model.NoPrefixForwardPatternModel p | true |
Lean.Meta.SynthInstance.Answer.mk | Lean.Meta.SynthInstance | Lean.Meta.AbstractMVarsResult → Lean.Expr → ℕ → Lean.Meta.SynthInstance.Answer | true |
ProbabilityTheory.«_aux_Mathlib_Probability_Kernel_Defs___macroRules_ProbabilityTheory_termKernel[_]___1» | Mathlib.Probability.Kernel.Defs | Lean.Macro | false |
Aesop.NormSeqResult.changed.injEq | Aesop.Search.Expansion.Norm | ∀ (goal : Lean.MVarId) (script : Array (Aesop.DisplayRuleName × Option (Array Aesop.Script.LazyStep)))
(goal_1 : Lean.MVarId) (script_1 : Array (Aesop.DisplayRuleName × Option (Array Aesop.Script.LazyStep))),
(Aesop.NormSeqResult.changed goal script = Aesop.NormSeqResult.changed goal_1 script_1) =
(goal = goal_... | true |
Std.Time.TimeZone.instInhabitedUTLocal | Std.Time.Zoned.ZoneRules | Inhabited Std.Time.TimeZone.UTLocal | true |
_private.Mathlib.Algebra.Group.Submonoid.Membership.0.Submonoid.mem_sup._simp_1_3 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | false |
Nat.totient_dvd_of_dvd | Mathlib.Data.Nat.Totient | ∀ {a b : ℕ}, a ∣ b → a.totient ∣ b.totient | true |
Unitization.real_cfcₙ_eq_cfc_inr | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] (a : A) (f : ℝ → ℝ),
autoParam (f 0 = 0) Unitization.real_cfcₙ_eq_cfc_inr._auto_1 → ↑(cfcₙ f a) = cfc f ↑a | true |
Lean.Elab.Tactic.Do.SplitInfo.noConfusionType | Lean.Elab.Tactic.Do.VCGen.Split | Sort u → Lean.Elab.Tactic.Do.SplitInfo → Lean.Elab.Tactic.Do.SplitInfo → Sort u | false |
Submodule.orthogonalBilin._proof_2 | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {R₁ : Type u_2} {M : Type u_3} {M₁ : Type u_4} [inst : CommRing R] [inst_1 : CommRing R₁]
[inst_2 : AddCommGroup M₁] [inst_3 : Module R₁ M₁] [inst_4 : AddCommGroup M] [inst_5 : Module R M] {I₁ I₂ : R₁ →+* R}
(N : Submodule R₁ M₁) (B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] M) {a b : M₁},
a ∈ {m | ∀ n ∈ N, B.IsOrt... | false |
Aesop.Options'.mk | Aesop.Options.Internal | Aesop.Options → Bool → Option ℕ → Aesop.Options' | true |
List.not_lt_of_mem_argmax | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] [inst_1 : DecidableLT β] {f : α → β} {l : List α} {a m : α},
a ∈ l → m ∈ List.argmax f l → ¬f m < f a | true |
CategoryTheory.ComposableArrows.map'_inv_eq_inv_map'._proof_2 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n m : ℕ}, n + 1 ≤ m → n ≤ m | false |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.byteIdx_offset_le_utf8ByteSize._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁.byteIdx ≤ i₂.byteIdx) = (i₁ ≤ i₂) | false |
Commute.conj_iff | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : Group G] {a b : G} (h : G), Commute (h * a * h⁻¹) (h * b * h⁻¹) ↔ Commute a b | true |
_private.Mathlib.Data.Finset.Lattice.Lemmas.0.Finset.singleton_inter_of_notMem._simp_1_1 | Mathlib.Data.Finset.Lattice.Lemmas | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s₁ s₂ : Finset α}, (a ∈ s₁ ∩ s₂) = (a ∈ s₁ ∧ a ∈ s₂) | false |
ENNReal.instOrderBot._aux_1 | Mathlib.Data.ENNReal.Basic | ENNReal | false |
Lean.Meta.Grind.Arith.CommRing.State.rings._default | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Array Lean.Meta.Grind.Arith.CommRing.CommRing | false |
Lean.Lsp.WorkDoneProgressReport.kind | Lean.Data.Lsp.Basic | Lean.Lsp.WorkDoneProgressReport → String | true |
_private.Mathlib.Topology.Semicontinuity.Hemicontinuity.0.upperHemicontinuous_iff_forall_isOpen._simp_1_2 | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → Set β} {x : α},
UpperHemicontinuousAt f x = ∀ (u : Set β), IsOpen u → f x ⊆ u → ∀ᶠ (x' : α) in nhds x, f x' ⊆ u | false |
_private.Lean.Environment.0.Lean.Environment.RealizeConstResult.noConfusion | Lean.Environment | {P : Sort u} →
{t t' : Lean.Environment.RealizeConstResult✝} → t = t' → Lean.Environment.RealizeConstResult.noConfusionType✝ P t t' | false |
Lean.Elab.Structural.IndGroupInfo.all | Lean.Elab.PreDefinition.Structural.IndGroupInfo | Lean.Elab.Structural.IndGroupInfo → Array Lean.Name | true |
CategoryTheory.Equivalence.precoherent_isSheaf_iff_of_essentiallySmall | Mathlib.CategoryTheory.Sites.Coherent.Equivalence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Precoherent C] (A : Type u_3)
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] [inst_3 : CategoryTheory.EssentiallySmall.{u_4, v_1, u_1} C]
(F : CategoryTheory.Functor Cᵒᵖ A),
CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coh... | true |
Lean.IR.JoinPointId.mk.sizeOf_spec | Lean.Compiler.IR.Basic | ∀ (idx : Lean.IR.Index), sizeOf { idx := idx } = 1 + sizeOf idx | true |
TrivSqZeroExt.addMonoid._proof_6 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddMonoid R] [inst_1 : AddMonoid M],
autoParam
(∀ (n : ℕ) (x : TrivSqZeroExt R M),
TrivSqZeroExt.addMonoid._aux_3 (n + 1) x = TrivSqZeroExt.addMonoid._aux_3 n x + x)
AddMonoid.nsmul_succ._autoParam | false |
Std.DHashMap.Const.getD | Std.Data.DHashMap.Basic | {α : Type u} → {x : BEq α} → {x_1 : Hashable α} → {β : Type v} → (Std.DHashMap α fun x => β) → α → β → β | true |
CategoryTheory.Comma.inhabited | Mathlib.CategoryTheory.Comma.Basic | {T : Type u₃} →
[inst : CategoryTheory.Category.{v₃, u₃} T] →
[Inhabited T] → Inhabited (CategoryTheory.Comma (CategoryTheory.Functor.id T) (CategoryTheory.Functor.id T)) | true |
BoundedContinuousFunction.instCStarAlgebra._proof_2 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_2} {A : Type u_1} [inst : TopologicalSpace α] [inst_1 : CStarAlgebra A],
CompleteSpace (BoundedContinuousFunction α A) | false |
_private.Mathlib.Tactic.SplitIfs.0.Mathlib.Tactic.SplitPosition.hyp.inj | Mathlib.Tactic.SplitIfs | ∀ {fvarId fvarId_1 : Lean.FVarId},
Mathlib.Tactic.SplitPosition.hyp✝ fvarId = Mathlib.Tactic.SplitPosition.hyp✝¹ fvarId_1 → fvarId = fvarId_1 | true |
Module.Relations.Solution.ofQuotient_π | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] (relations : Module.Relations A),
(Module.Relations.Solution.ofQuotient relations).π = (Submodule.span A (Set.range relations.relation)).mkQ | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_insertMany_list_of_mem._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
ProofWidgets.instToJsonMakeEditLinkProps.toJson | ProofWidgets.Component.MakeEditLink | ProofWidgets.MakeEditLinkProps → Lean.Json | true |
Manifold.IsImmersionAtOfComplement.instNormedAddCommGroupSmallComplement._proof_27 | Mathlib.Geometry.Manifold.Immersion | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {E'' : Type u_1} {F : Type u_4}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E'']
[inst_4 : NormedSpace 𝕜 E''] [inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F] {H : Type u_5}
[inst_7 : Topo... | false |
isEmpty_pprod | Mathlib.Logic.IsEmpty.Basic | ∀ {α : Sort u_1} {β : Sort u_2}, IsEmpty (α ×' β) ↔ IsEmpty α ∨ IsEmpty β | true |
IsDiscreteValuationRing.casesOn | Mathlib.RingTheory.DiscreteValuationRing.Basic | {R : Type u} →
[inst : CommRing R] →
[inst_1 : IsDomain R] →
{motive : IsDiscreteValuationRing R → Sort u_1} →
(t : IsDiscreteValuationRing R) →
([toIsPrincipalIdealRing : IsPrincipalIdealRing R] →
[toIsLocalRing : IsLocalRing R] → (not_a_field' : IsLocalRing.maximalIdeal R ≠... | false |
RelEmbedding.swap | Mathlib.Order.RelIso.Basic | {α : Type u_1} → {β : Type u_2} → {r : α → α → Prop} → {s : β → β → Prop} → r ↪r s → Function.swap r ↪r Function.swap s | true |
Std.DTreeMap.Equiv.getEntryLE_eq.match_1 | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} {t₁ : Std.DTreeMap α β cmp} {k : α} (x : α)
(motive : x ∈ t₁ ∧ (cmp x k).isLE = true → Prop) (x_1 : x ∈ t₁ ∧ (cmp x k).isLE = true),
(∀ (h₁ : x ∈ t₁) (h₂ : (cmp x k).isLE = true), motive ⋯) → motive x_1 | false |
DedekindCut.instCompleteLinearOrder._proof_4 | Mathlib.Order.Completion | ∀ {α : Type u_1} [inst : LinearOrder α] (a b : DedekindCut α), Lattice.inf a b ≤ a | false |
GaloisCoinsertion.ofDual._proof_3 | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] {l : αᵒᵈ → βᵒᵈ} {u : βᵒᵈ → αᵒᵈ}
(x : GaloisCoinsertion l u) (a : βᵒᵈ) (h : a ≤ l (u a)), x.choice a h = u a | false |
Std.DHashMap.Internal.Raw₀.getKey_insertMany_emptyWithCapacity_list_of_mem | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α]
{l : List ((a : α) × β a)} {k k' : α},
(k == k') = true →
List.Pairwise (fun a b => (a.fst == b.fst) = false) l →
k ∈ List.map Sigma.fst l →
∀ {h' : (↑(Std.DHashMap.Internal.Raw₀.emptyWithCapacity.... | true |
Lean.PrettyPrinter.Parenthesizer.instCoeForallForallParenthesizerAliasValue | Lean.PrettyPrinter.Parenthesizer | Coe (Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer)
Lean.PrettyPrinter.Parenthesizer.ParenthesizerAliasValue | true |
Std.DTreeMap.Internal.Impl.equiv_iff_toList_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t₁.WF → t₂.WF → (t₁.Equiv t₂ ↔ t₁.toList = t₂.toList) | true |
Std.Do.PredTrans.Conjunctive | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α : Type u} → (Std.Do.PostCond α ps → Std.Do.Assertion ps) → Prop | true |
Lean.DataValue.ofString.inj | Lean.Data.KVMap | ∀ {v v_1 : String}, Lean.DataValue.ofString v = Lean.DataValue.ofString v_1 → v = v_1 | true |
Multiset.coe_foldl | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {β : Type v} (f : β → α → β) [inst : RightCommutative f] (b : β) (l : List α),
Multiset.foldl f b ↑l = List.foldl f b l | true |
UInt64.ofFin_mod | Init.Data.UInt.Lemmas | ∀ (a b : Fin UInt64.size), UInt64.ofFin (a % b) = UInt64.ofFin a % UInt64.ofFin b | true |
integral_cos_sq_sub_sin_sq | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {a b : ℝ}, ∫ (x : ℝ) in a..b, Real.cos x ^ 2 - Real.sin x ^ 2 = Real.sin b * Real.cos b - Real.sin a * Real.cos a | true |
CategoryTheory.Comma.mapFst_inv_app | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] {A' : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} A'] {B' : Type u₅} [inst_4 : CategoryTheory.Category.{v₅, u₅} B']
{T' : Type... | true |
Function.Exact.rangeFactorization | Mathlib.Algebra.Exact | ∀ {M : Type u_2} {N : Type u_4} {P : Type u_6} {f : M → N} {g : N → P} [inst : Zero P],
Function.Exact f g → ∀ (hg : 0 ∈ Set.range g), Function.Exact Subtype.val (Set.rangeFactorization g) | true |
_private.Init.Data.Array.BasicAux.0.Array.mapM'.go._unsafe_rec | Init.Data.Array.BasicAux | {m : Type u_1 → Type u_2} →
{α : Type u_3} →
{β : Type u_1} →
[Monad m] →
(α → m β) → (as : Array α) → (i : ℕ) → { bs // bs.size = i } → i ≤ as.size → m { bs // bs.size = as.size } | false |
Lean.Environment.PromiseCheckedResult.mainEnv | Lean.Environment | Lean.Environment.PromiseCheckedResult → Lean.Environment | true |
BitVec.or_allOnes | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, x ||| BitVec.allOnes w = BitVec.allOnes w | true |
Mathlib.Tactic.Sat._aux_Mathlib_Tactic_Sat_FromLRAT___elabRules_Mathlib_Tactic_Sat_commandLrat_proof_Example_____1 | Mathlib.Tactic.Sat.FromLRAT | Lean.Elab.Command.CommandElab | false |
Mathlib.Tactic.BicategoryLike.eval._sunfold | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {ρ : Type} →
[Mathlib.Tactic.BicategoryLike.MonadMor₁ (Mathlib.Tactic.BicategoryLike.CoherenceM ρ)] →
[Mathlib.Tactic.BicategoryLike.MonadMor₂Iso (Mathlib.Tactic.BicategoryLike.CoherenceM ρ)] →
[Mathlib.Tactic.BicategoryLike.MonadNormalExpr (Mathlib.Tactic.BicategoryLike.CoherenceM ρ)] →
[Mathlib.Ta... | false |
Polynomial.iterate_derivative_natCast_mul | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u} [inst : Semiring R] {n k : ℕ} {f : Polynomial R},
(⇑Polynomial.derivative)^[k] (↑n * f) = ↑n * (⇑Polynomial.derivative)^[k] f | true |
_private.Mathlib.Geometry.Euclidean.Sphere.Tangent.0.EuclideanGeometry.Sphere.isIntTangent_iff_dist_center._simp_1_9 | Mathlib.Geometry.Euclidean.Sphere.Tangent | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | false |
_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.contDiff_iff_contDiffAt._simp_1_1 | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{n : WithTop ℕ∞}, ContDiff 𝕜 n f = ContDiffOn 𝕜 n f Set.univ | false |
_private.Mathlib.Combinatorics.Matroid.IndepAxioms.0.Matroid.existsMaximalSubsetProperty_of_bdd._simp_1_1 | Mathlib.Combinatorics.Matroid.IndepAxioms | ∀ {n : ℕ∞} {k : ℕ}, (n ≤ ↑k) = ∃ n₀, n = ↑n₀ ∧ n₀ ≤ k | false |
ContinuousMap.instLatticeOfTopologicalLattice._proof_2 | Mathlib.Topology.ContinuousMap.Ordered | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Lattice β]
[inst_3 : TopologicalLattice β] (a b : C(α, β)), SemilatticeInf.inf a b ≤ b | false |
_private.Mathlib.RingTheory.Noetherian.Defs.0.isNoetherian_iff'.match_1_1 | Mathlib.RingTheory.Noetherian.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(motive : IsNoetherian R M → Prop) (x : IsNoetherian R M), (∀ (h : ∀ (s : Submodule R M), s.FG), motive ⋯) → motive x | false |
MeasureTheory.AEStronglyMeasurable.smul | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{𝕜 : Type u_5} [inst_1 : TopologicalSpace 𝕜] [inst_2 : SMul 𝕜 β] [ContinuousSMul 𝕜 β] {f : α → 𝕜} {g : α → β},
MeasureTheory.AEStronglyMeasurable f μ →
MeasureTheory.AEStronglyMeasurable g μ... | true |
Lean.Try.Config.mk | Init.Try | Bool → Bool → Bool → ℕ → Bool → Bool → Bool → Bool → Bool → Lean.Try.Config | true |
SemilatSupCat.instLargeCategory._proof_2 | Mathlib.Order.Category.Semilat | ∀ {X Y : SemilatSupCat} (f : SupBotHom X.X Y.X), (SupBotHom.id Y.X).comp f = f | false |
LinearIndependent.finite_of_le_span_finite | Mathlib.LinearAlgebra.Dimension.StrongRankCondition | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [StrongRankCondition R]
{ι : Type u_2} (v : ι → M),
LinearIndependent R v → ∀ (w : Set M) [Finite ↑w], Set.range v ≤ ↑(Submodule.span R w) → Finite ι | true |
Mathlib.Meta.NormNum.isNat_ordinalSub | Mathlib.Tactic.NormNum.Ordinal | ∀ {a b : Ordinal.{u}} {an bn rn : ℕ},
Mathlib.Meta.NormNum.IsNat a an →
Mathlib.Meta.NormNum.IsNat b bn → an - bn = rn → Mathlib.Meta.NormNum.IsNat (a - b) rn | true |
_private.Mathlib.Algebra.Field.Periodic.0.Function.Periodic.exists_mem_Ico₀.match_1_1 | Mathlib.Algebra.Field.Periodic | ∀ {α : Type u_1} {c : α} [inst : AddCommGroup α] [inst_1 : LinearOrder α] (x : α)
(motive : (∃! k, 0 ≤ x - k • c ∧ x - k • c < c) → Prop) (x_1 : ∃! k, 0 ≤ x - k • c ∧ x - k • c < c),
(∀ (n : ℤ) (H : 0 ≤ x - n • c ∧ x - n • c < c)
(right : ∀ (y : ℤ), (fun k => 0 ≤ x - k • c ∧ x - k • c < c) y → y = n), motive ... | false |
hasMFDerivWithinAt_insert | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
List.Pairwise.imp_of_mem | Init.Data.List.Pairwise | ∀ {α : Type u_1} {l : List α} {R S : α → α → Prop},
(∀ {a b : α}, a ∈ l → b ∈ l → R a b → S a b) → List.Pairwise R l → List.Pairwise S l | true |
Matrix.TransvectionStruct | Mathlib.LinearAlgebra.Matrix.Transvection | Type u_1 → Type u₂ → Type (max u_1 u₂) | true |
Lean.Kernel.Exception.other.noConfusion | Lean.Environment | {P : Sort u} →
{msg msg' : String} → Lean.Kernel.Exception.other msg = Lean.Kernel.Exception.other msg' → (msg = msg' → P) → P | false |
CategoryTheory.HasShift.induced._proof_5 | Mathlib.CategoryTheory.Shift.Induced | ∀ {C : Type u_5} {D : Type u_2} [inst : CategoryTheory.Category.{u_4, u_5} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) (A : Type u_3) [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] (s : A → CategoryTheory.Functor D D)
(i : (a : A) → F.comp (s a) ≅ (CategoryTh... | false |
IsContMDiffRiemannianBundle.rec | Mathlib.Geometry.Manifold.VectorBundle.Riemannian | {EB : Type u_1} →
[inst : NormedAddCommGroup EB] →
[inst_1 : NormedSpace ℝ EB] →
{HB : Type u_2} →
[inst_2 : TopologicalSpace HB] →
{IB : ModelWithCorners ℝ EB HB} →
{n : WithTop ℕ∞} →
{B : Type u_3} →
[inst_3 : TopologicalSpace B] →
... | false |
_private.Mathlib.Data.Set.Pairwise.Basic.0.Set.pairwise_insert_of_symmetric._simp_1_2 | Mathlib.Data.Set.Pairwise.Basic | ∀ {a : Prop}, (a ∧ a) = a | false |
Lean.Grind.CommRing.Poly.denote_mulC_nc_go | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} {c : ℕ} [inst : Lean.Grind.Ring α] [Lean.Grind.IsCharP α c] (ctx : Lean.Grind.CommRing.Context α)
(p₁ p₂ acc : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.denote ctx (Lean.Grind.CommRing.Poly.mulC_nc.go p₂ c p₁ acc) =
Lean.Grind.CommRing.Poly.denote ctx acc +
Lean.Grind.CommRing.P... | true |
Lean.Grind.Linarith.Expr.toPoly'.go.eq_7 | Init.Grind.Ordered.Linarith | ∀ (coeff : ℤ) (a : Lean.Grind.Linarith.Expr),
Lean.Grind.Linarith.Expr.toPoly'.go coeff a.neg = Lean.Grind.Linarith.Expr.toPoly'.go (-coeff) a | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.