name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
FirstOrder.Language.Theory.ModelsBoundedFormula.eq_1 | Mathlib.ModelTheory.Equivalence | ∀ {L : FirstOrder.Language} (T : L.Theory) {α : Type w} {n : ℕ} (φ : L.BoundedFormula α n),
T ⊨ᵇ φ = ∀ (M : T.ModelType) (v : α → ↑M) (xs : Fin n → ↑M), φ.Realize v xs | null | true |
Lean.IO.FS.Stream.writeNotification | Lean.Data.JsonRpc | {α : Type u_1} → [Lean.ToJson α] → IO.FS.Stream → Lean.JsonRpc.Notification α → IO Unit | null | true |
ContinuousMap.mem_setOfIdeal | Mathlib.Topology.ContinuousMap.Ideals | ∀ {X : Type u_1} {R : Type u_2} [inst : TopologicalSpace X] [inst_1 : Semiring R] [inst_2 : TopologicalSpace R]
[inst_3 : IsTopologicalSemiring R] {I : Ideal C(X, R)} {x : X}, x ∈ ContinuousMap.setOfIdeal I ↔ ∃ f ∈ I, f x ≠ 0 | null | true |
PowerSeries.idealX._proof_1 | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_1) [inst : Field K], Ideal.span {PowerSeries.X} ≠ ⊥ | null | false |
Graph.deleteEdges_le._simp_1 | Mathlib.Combinatorics.Graph.Delete | ∀ {α : Type u_1} {β : Type u_2} {G : Graph α β} {F : Set β}, (G.deleteEdges F ≤ G) = True | null | false |
ComplexShape.Embedding.splittingExtend._proof_1 | Mathlib.Algebra.Homology.Embedding.Splitting | ∀ {ι₁ : Type u_2} {ι₂ : Type u_1} {c₁ : ComplexShape ι₁} {c₂ : ComplexShape ι₂} (e : c₁.Embedding c₂) (i₂ : ι₂),
(¬∃ i₁, e.f i₁ = i₂) → ∀ (i : ι₁), e.f i ≠ i₂ | null | false |
Lean.Parser.Command.prefix.formatter | Lean.Parser.Syntax | Lean.PrettyPrinter.Formatter | null | true |
Std.DTreeMap.Const.minKey?_modify_eq_minKey? | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {k : α} {f : β → β}, (Std.DTreeMap.Const.modify t k f).minKey? = t.minKey? | null | true |
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 | A Hilbert space admits a Hilbert basis extending a given orthonormal subset. | 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, ⋯⟩ | null | 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 | null | 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... | null | false |
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_... | null | false |
AddCon.mkAddHom_apply | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} [inst : Add M] (c : AddCon M) (a : M), c.mkAddHom a = ↑a | null | true |
Int.Internal.Linear.of_var_eq_mul_cert | Init.Data.Int.Linear | Int.Internal.Linear.Var → ℤ → Int.Internal.Linear.Var → Int.Internal.Linear.Poly → Bool | null | true |
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 | null | 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 | null | false |
unitInterval.tendsto_sigmoid_atBot | Mathlib.Analysis.SpecialFunctions.Sigmoid | Filter.Tendsto unitInterval.sigmoid Filter.atBot (nhds 0) | null | true |
CategoryTheory.GradedObject.comapEquiv._proof_1 | Mathlib.CategoryTheory.GradedObject | ∀ {β γ : Type u_1} (e : β ≃ γ), (fun i => i) = ⇑e.symm ∘ ⇑e | null | 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... | null | 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) (... | null | 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₃ | null | true |
Lean.Try.Config.ctorIdx | Init.Try | Lean.Try.Config → ℕ | null | 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... | null | true |
IsOfFinAddOrder.nsmul | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddMonoid G] {a : G} {n : ℕ}, IsOfFinAddOrder a → IsOfFinAddOrder (n • a) | null | true |
_private.Mathlib.Order.Nucleus.0.Nucleus.instHImp._simp_4 | Mathlib.Order.Nucleus | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∀ (a : α), b) = b | null | 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 | null | 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) | null | true |
MeasurableInf.measurable_const_inf._autoParam | Mathlib.MeasureTheory.Order.Lattice | Lean.Syntax | null | false |
IsPrimePow.ne_zero | Mathlib.Algebra.IsPrimePow | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] [IsReduced R] {n : R}, IsPrimePow n → n ≠ 0 | null | 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' | null | true |
ProbabilityTheory.«_aux_Mathlib_Probability_Kernel_Defs___macroRules_ProbabilityTheory_termKernel[_]___1» | Mathlib.Probability.Kernel.Defs | Lean.Macro | null | false |
Lean.Meta.SynthInstance.Answer.mk | Lean.Meta.SynthInstance | Lean.Meta.AbstractMVarsResult → Lean.Expr → ℕ → Lean.Meta.SynthInstance.Answer | null | true |
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_... | null | true |
Std.Time.TimeZone.instInhabitedUTLocal | Std.Time.Zoned.ZoneRules | Inhabited Std.Time.TimeZone.UTLocal | null | 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⟩ | null | false |
Nat.totient_dvd_of_dvd | Mathlib.Data.Nat.Totient | ∀ {a b : ℕ}, a ∣ b → a.totient ∣ b.totient | null | 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 | note: the version for `ℝ≥0`, `Unitization.nnreal_cfcₙ_eq_cfc_inr`, can be found in
`Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Order.lean` | true |
Mathlib.Tactic.Ring.Common.ExSum.recOn | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{BaseType : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
{motive_1 : (e : Q(«$α»)) → Mathlib.Tactic.Ring.Common.ExBase BaseType sα e → Sort u} →
{motive_2 : (e : Q(«$α»)) → Mathlib.Tactic.Ring.Common.ExProd BaseType sα e → Sort u} →
{moti... | null | false |
Submodule.orthogonalBilin._proof_2 | Mathlib.LinearAlgebra.SesquilinearForm.Orthogonal | ∀ {R : Type u_6} {R₁ : Type u_3} {R₂ : Type u_5} {M : Type u_4} {M₁ : Type u_2} {M₂ : Type u_1} [inst : CommSemiring R]
[inst_1 : CommSemiring R₁] [inst_2 : CommSemiring R₂] [inst_3 : AddCommMonoid M] [inst_4 : Module R M]
[inst_5 : AddCommMonoid M₁] [inst_6 : Module R₁ M₁] [inst_7 : AddCommMonoid M₂] [inst_8 : Mod... | null | false |
Aesop.Options'.mk | Aesop.Options.Internal | Aesop.Options → Bool → Option ℕ → Aesop.Options' | null | 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 | null | true |
CategoryTheory.ComposableArrows.map'_inv_eq_inv_map'._proof_2 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n m : ℕ}, n + 1 ≤ m → n ≤ m | null | false |
AddAut.characteristic._proof_15 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) [H.Characteristic] (h k : ↥H),
↑(h + k) ∈ AddSubgroup.comap (AddEquiv.toAddMonoidHom 0) H | null | 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₂) | null | 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 | null | 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₂) | null | false |
Lean.Meta.Grind.Arith.CommRing.State.rings._default | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Array Lean.Meta.Grind.Arith.CommRing.CommRing | null | false |
Lean.Lsp.WorkDoneProgressReport.kind | Lean.Data.Lsp.Basic | Lean.Lsp.WorkDoneProgressReport → String | null | true |
_private.Mathlib.Tactic.Translate.Expr.0.Mathlib.Tactic.Translate.shouldTranslate.match_1 | Mathlib.Tactic.Translate.Expr | (motive : Lean.Expr → Sort u_1) →
(f : Lean.Expr) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.Binder... | null | false |
_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 α] {f : α → Set β} {x : α} [inst_1 : TopologicalSpace β],
UpperHemicontinuousAt f x = ∀ (u : Set β), IsOpen u → f x ⊆ u → ∀ᶠ (x' : α) in nhds x, f x' ⊆ u | null | 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' | null | false |
Vector.scanrM._proof_6 | Batteries.Data.Vector.Basic | ∀ {n : ℕ}, ∀ i ≤ n, 0 < i → n - i + 1 = n - (i - 1) | null | false |
Lean.Elab.Structural.IndGroupInfo.all | Lean.Elab.PreDefinition.Structural.IndGroupInfo | Lean.Elab.Structural.IndGroupInfo → Array Lean.Name | null | 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... | The coherent sheaf condition on an essentially small site can be checked after precomposing with
the equivalence with a small category.
| true |
Lean.IR.JoinPointId.mk.sizeOf_spec | Lean.Compiler.IR.Basic | ∀ (idx : Lean.IR.Index), sizeOf { idx := idx } = 1 + sizeOf idx | null | true |
TrivSqZeroExt.addMonoid._proof_6 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddMonoid R] [inst_1 : AddMonoid M] (a b c : TrivSqZeroExt R M),
a + b + c = a + (b + c) | null | false |
Std.DHashMap.Const.getD | Std.Data.DHashMap.Basic | {α : Type u} → {x : BEq α} → {x_1 : Hashable α} → {β : Type v} → (Std.DHashMap α fun x => β) → α → β → β | Tries to retrieve the mapping for the given key, returning `fallback` if no such mapping is present.
| 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)) | null | 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) | null | 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 | null | 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 | null | 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) | null | false |
ProofWidgets.instToJsonMakeEditLinkProps.toJson | ProofWidgets.Component.MakeEditLink | ProofWidgets.MakeEditLinkProps → Lean.Json | null | 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... | null | false |
isEmpty_pprod | Mathlib.Basic.IsEmpty.Basic | ∀ {α : Sort u_1} {β : Sort u_2}, IsEmpty (α ×' β) ↔ IsEmpty α ∨ IsEmpty β | null | 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 ≠... | null | 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 | A relation embedding is also a relation embedding between dual relations. | 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 | null | false |
DedekindCut.instCompleteLinearOrder._proof_4 | Mathlib.Order.Completion | ∀ {α : Type u_1} [inst : LinearOrder α] (a b : DedekindCut α), Lattice.inf a b ≤ a | null | 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 | null | 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.... | null | true |
Lean.PrettyPrinter.Parenthesizer.instCoeForallForallParenthesizerAliasValue | Lean.PrettyPrinter.Parenthesizer | Coe (Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer)
Lean.PrettyPrinter.Parenthesizer.ParenthesizerAliasValue | null | 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) | null | true |
_private.Batteries.Data.BinaryHeap.WF.0.Batteries.BinaryHeap.WF.TopDown.below_of_set._proof_1_1 | Batteries.Data.BinaryHeap.WF | ∀ {sz : ℕ} {i : Fin sz} (j : Fin sz), ↑i < ↑j → ↑i = ↑j → False | null | false |
Std.Do.PredTrans.Conjunctive | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α : Type u} → (Std.Do.PostCond α ps → Std.Do.Assertion ps) → Prop | Transforming a conjunction of postconditions is the same as the conjunction of transformed
postconditions.
| true |
Lean.DataValue.ofString.inj | Lean.Data.KVMap | ∀ {v v_1 : String}, Lean.DataValue.ofString v = Lean.DataValue.ofString v_1 → v = v_1 | null | 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 | null | true |
UInt64.ofFin_mod | Init.Data.UInt.Lemmas | ∀ (a b : Fin UInt64.size), UInt64.ofFin (a % b) = UInt64.ofFin a % UInt64.ofFin b | null | 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 | null | 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... | null | true |
Function.Exact.rangeFactorization | Mathlib.Algebra.Exact.Basic | ∀ {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) | If two maps `f : M → N` and `g : N → P` are exact, then the induced maps
`Set.range f → N → Set.range g` are exact.
Note that if you already have an instance `[Zero (Set.range g)]` (which is unlikely) this lemma
may not apply if the zero of `Set.range g` is not definitionally equal to `⟨0, hg⟩`. | true |
SSet.PtSimplex.relStructCastSuccEquivMulStruct._proof_16 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op { len := 0 })} {f g : X.PtSimplex n x} {i : Fin n}
(h : SSet.PtSimplex.MulStruct SSet.RelativeMorphism.const f g i) (j : Fin (n + 2)),
i.castSucc.succ < j → CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ j) h.map = SSet.const x | null | false |
Lean.Meta.Sym.dsimp.match_1 | Lean.Meta.Sym.DSimp.DSimpM | (motive : Lean.Meta.Sym.DSimp.Result → Sort u_1) →
(__do_lift : Lean.Meta.Sym.DSimp.Result) →
((done : Bool) → motive (Lean.Meta.Sym.DSimp.Result.rfl done)) →
((e' : Lean.Expr) → (done : Bool) → motive (Lean.Meta.Sym.DSimp.Result.step e' done)) → motive __do_lift | null | false |
_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 } | null | false |
Lean.Environment.PromiseCheckedResult.mainEnv | Lean.Environment | Lean.Environment.PromiseCheckedResult → Lean.Environment | Resulting "main branch" environment. Accessing the kernel environment will block until
`PromiseCheckedResult.commitChecked` has been called.
| true |
BitVec.or_allOnes | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, x ||| BitVec.allOnes w = BitVec.allOnes w | null | true |
CategoryTheory.Functor.instHasWeightedLimitObjTypeHasWeightedLimit | Mathlib.CategoryTheory.Limits.Weighted.HasWeightedLimit | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {C : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} C]
(F : CategoryTheory.Functor J C) (W : F.hasWeightedLimit.FullSubcategory),
CategoryTheory.Limits.HasWeightedLimit W.obj F | null | 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 | A macro for producing SAT proofs from CNF / LRAT files.
These files are commonly used in the SAT community for writing proofs.
The input to the `lrat_proof` command is the name of the theorem to define,
and the statement (written in CNF format) and the proof (in LRAT format).
For example:
```
lrat_proof foo
"p cnf 2... | 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... | null | 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 | null | 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 | null | 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 | null | 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 | null | 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 | null | 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 μ... | null | true |
Lean.Try.Config.mk | Init.Try | Bool → Bool → Bool → ℕ → Bool → Bool → Bool → Bool → Bool → Lean.Try.Config | null | 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 | null | false |
BoundedContinuousFunction.coe_npowRec._f | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u} [inst : TopologicalSpace α] {R : Type u_1} [inst_1 : SeminormedRing R]
(f : BoundedContinuousFunction α R) (x : ℕ) (f_1 : Nat.below x), ⇑(npowRec x f) = ⇑f ^ x | null | 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 ι | If `R` satisfies the strong rank condition,
then any linearly independent family `v : ι → M`
contained in the span of some finite `w : Set M`,
is itself finite.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.