name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
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' |
String.Slice.Pattern.Model.CharPred.instNoPrefixForwardPatternModelForallCharBool | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Bool}, String.Slice.Pattern.Model.NoPrefixForwardPatternModel p |
Lean.Meta.SynthInstance.Answer.mk | Lean.Meta.SynthInstance | Lean.Meta.AbstractMVarsResult → Lean.Expr → ℕ → Lean.Meta.SynthInstance.Answer |
ProbabilityTheory.«_aux_Mathlib_Probability_Kernel_Defs___macroRules_ProbabilityTheory_termKernel[_]___1» | Mathlib.Probability.Kernel.Defs | Lean.Macro |
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_1 ∧ script = script_1) |
Std.Time.TimeZone.instInhabitedUTLocal | Std.Time.Zoned.ZoneRules | Inhabited Std.Time.TimeZone.UTLocal |
_private.Mathlib.AlgebraicTopology.ExtraDegeneracy.0.CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.ofIso._simp_6 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X' X : CategoryTheory.SimplicialObject C} (f : X ⟶ X') {n : ℕ}
(i : Fin (n + 2)) {Z : C} (h : X'.obj (Opposite.op (SimplexCategory.mk n)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (f.app (Opposite.op (SimplexCategory.mk (n + 1))))
(CategoryTheory.CategoryStruct.comp (X'.δ i) h) =
CategoryTheory.CategoryStruct.comp (X.δ i)
(CategoryTheory.CategoryStruct.comp (f.app (Opposite.op (SimplexCategory.mk n))) h) |
_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⟩ |
Nat.totient_dvd_of_dvd | Mathlib.Data.Nat.Totient | ∀ {a b : ℕ}, a ∣ b → a.totient ∣ b.totient |
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 |
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 |
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.IsOrtho n m} → b ∈ {m | ∀ n ∈ N, B.IsOrtho n m} → ∀ n ∈ N, B.IsOrtho n (a + b) |
Aesop.Options'.mk | Aesop.Options.Internal | Aesop.Options → Bool → Option ℕ → Aesop.Options' |
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 |
CategoryTheory.ComposableArrows.map'_inv_eq_inv_map'._proof_2 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n m : ℕ}, n + 1 ≤ m → n ≤ m |
_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₂) |
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 |
_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₂) |
Lean.Meta.Grind.Arith.CommRing.State.rings._default | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Array Lean.Meta.Grind.Arith.CommRing.CommRing |
Lean.Lsp.WorkDoneProgressReport.kind | Lean.Data.Lsp.Basic | Lean.Lsp.WorkDoneProgressReport → String |
_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 |
_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' |
Lean.Elab.Structural.IndGroupInfo.all | Lean.Elab.PreDefinition.Structural.IndGroupInfo | Lean.Elab.Structural.IndGroupInfo → Array Lean.Name |
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.coherentTopology C) F ↔
CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology (CategoryTheory.SmallModel.{u_4, v_1, u_1} C))
((CategoryTheory.equivSmallModel C).inverse.op.comp F) |
Lean.IR.JoinPointId.mk.sizeOf_spec | Lean.Compiler.IR.Basic | ∀ (idx : Lean.IR.Index), sizeOf { idx := idx } = 1 + sizeOf idx |
Std.DHashMap.Const.getD | Std.Data.DHashMap.Basic | {α : Type u} → {x : BEq α} → {x_1 : Hashable α} → {β : Type v} → (Std.DHashMap α fun x => β) → α → β → β |
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)) |
BoundedContinuousFunction.instCStarAlgebra._proof_2 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_2} {A : Type u_1} [inst : TopologicalSpace α] [inst_1 : CStarAlgebra A],
CompleteSpace (BoundedContinuousFunction α A) |
_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 |
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 |
_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) |
ProofWidgets.instToJsonMakeEditLinkProps.toJson | ProofWidgets.Component.MakeEditLink | ProofWidgets.MakeEditLinkProps → Lean.Json |
isEmpty_pprod | Mathlib.Logic.IsEmpty.Basic | ∀ {α : Sort u_1} {β : Sort u_2}, IsEmpty (α ×' β) ↔ IsEmpty α ∨ IsEmpty β |
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 ≠ ⊥) → motive ⋯) →
motive t |
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 |
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 |
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 |
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.insertMany l)).contains k' = true},
(↑(Std.DHashMap.Internal.Raw₀.emptyWithCapacity.insertMany l)).getKey k' h' = k |
Lean.PrettyPrinter.Parenthesizer.instCoeForallForallParenthesizerAliasValue | Lean.PrettyPrinter.Parenthesizer | Coe (Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer)
Lean.PrettyPrinter.Parenthesizer.ParenthesizerAliasValue |
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) |
Std.Do.PredTrans.Conjunctive | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α : Type u} → (Std.Do.PostCond α ps → Std.Do.Assertion ps) → Prop |
Lean.DataValue.ofString.inj | Lean.Data.KVMap | ∀ {v v_1 : String}, Lean.DataValue.ofString v = Lean.DataValue.ofString v_1 → v = v_1 |
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 |
UInt64.ofFin_mod | Init.Data.UInt.Lemmas | ∀ (a b : Fin UInt64.size), UInt64.ofFin (a % b) = UInt64.ofFin a % UInt64.ofFin b |
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 |
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 u₆} [inst_5 : CategoryTheory.Category.{v₆, u₆} T'] {L : CategoryTheory.Functor A T}
{R : CategoryTheory.Functor B T} {L' : CategoryTheory.Functor A' T'} {R' : CategoryTheory.Functor B' T'}
{F₁ : CategoryTheory.Functor A A'} {F₂ : CategoryTheory.Functor B B'} {F : CategoryTheory.Functor T T'}
(α : F₁.comp L' ⟶ L.comp F) (β : R.comp F ⟶ F₂.comp R') (X : CategoryTheory.Comma L R),
(CategoryTheory.Comma.mapFst α β).inv.app X = CategoryTheory.CategoryStruct.id (F₁.obj X.left) |
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) |
_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 } |
Lean.Environment.PromiseCheckedResult.mainEnv | Lean.Environment | Lean.Environment.PromiseCheckedResult → Lean.Environment |
BitVec.or_allOnes | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, x ||| BitVec.allOnes w = BitVec.allOnes w |
Mathlib.Tactic.Sat._aux_Mathlib_Tactic_Sat_FromLRAT___elabRules_Mathlib_Tactic_Sat_commandLrat_proof_Example_____1 | Mathlib.Tactic.Sat.FromLRAT | Lean.Elab.Command.CommandElab |
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.Tactic.BicategoryLike.MkEval (Mathlib.Tactic.BicategoryLike.CoherenceM ρ)] →
[Mathlib.Tactic.BicategoryLike.MonadMor₂ (Mathlib.Tactic.BicategoryLike.CoherenceM ρ)] →
Lean.Name →
Mathlib.Tactic.BicategoryLike.Mor₂ →
Mathlib.Tactic.BicategoryLike.CoherenceM ρ Mathlib.Tactic.BicategoryLike.Eval.Result |
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 |
_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 |
_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 |
_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 |
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 |
_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 |
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 μ → MeasureTheory.AEStronglyMeasurable (fun x => f x • g x) μ |
Lean.Try.Config.mk | Init.Try | Bool → Bool → Bool → ℕ → Bool → Bool → Bool → Bool → Bool → Lean.Try.Config |
SemilatSupCat.instLargeCategory._proof_2 | Mathlib.Order.Category.Semilat | ∀ {X Y : SemilatSupCat} (f : SupBotHom X.X Y.X), (SupBotHom.id Y.X).comp f = f |
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 ι |
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 |
_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 ⋯) →
motive x_1 |
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 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'} {x : M} {s : Set M}
{f' : TangentSpace I x →L[𝕜] TangentSpace I' (f x)} {y : M},
HasMFDerivWithinAt I I' f (insert y s) x f' ↔ HasMFDerivWithinAt I I' f s x f' |
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 |
Matrix.TransvectionStruct | Mathlib.LinearAlgebra.Matrix.Transvection | Type u_1 → Type u₂ → Type (max u_1 u₂) |
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 |
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) ≅ (CategoryTheory.shiftFunctor C a).comp F)
[inst_4 : ((CategoryTheory.Functor.whiskeringLeft C D D).obj F).Full]
[inst_5 : ((CategoryTheory.Functor.whiskeringLeft C D D).obj F).Faithful] (n : A) (X : D),
(CategoryTheory.HasShift.Induced.add F s i 0 n).hom.app X =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
((s n).map ((CategoryTheory.HasShift.Induced.zero F s i).inv.app X)) |
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] →
[inst_4 : ChartedSpace HB B] →
{F : Type u_4} →
[inst_5 : NormedAddCommGroup F] →
[inst_6 : NormedSpace ℝ F] →
{E : B → Type u_5} →
[inst_7 : TopologicalSpace (Bundle.TotalSpace F E)] →
[inst_8 : (x : B) → NormedAddCommGroup (E x)] →
[inst_9 : (x : B) → InnerProductSpace ℝ (E x)] →
[inst_10 : FiberBundle F E] →
[inst_11 : VectorBundle ℝ F E] →
{motive : IsContMDiffRiemannianBundle IB n F E → Sort u} →
((exists_contMDiff :
∃ g,
(ContMDiff IB (IB.prod (modelWithCornersSelf ℝ (F →L[ℝ] F →L[ℝ] ℝ))) n
fun b => ⟨b, g b⟩) ∧
∀ (x : B) (v w : E x), inner ℝ v w = ((g x) v) w) →
motive ⋯) →
(t : IsContMDiffRiemannianBundle IB n F E) → motive t |
_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 |
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.Poly.denote ctx p₁ * Lean.Grind.CommRing.Poly.denote ctx p₂ |
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 |
CategoryTheory.evaluation._proof_4 | Mathlib.CategoryTheory.Products.Basic | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {x x_1 : C} (f : x ⟶ x_1) ⦃X Y : CategoryTheory.Functor C D⦄
(f_1 : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
({ obj := fun F => F.obj x, map := fun {X Y} α => α.app x, map_id := ⋯, map_comp := ⋯ }.map f_1) (Y.map f) =
CategoryTheory.CategoryStruct.comp (X.map f)
({ obj := fun F => F.obj x_1, map := fun {X Y} α => α.app x_1, map_id := ⋯, map_comp := ⋯ }.map f_1) |
QPF.Wequiv.abs | Mathlib.Data.QPF.Univariate.Basic | ∀ {F : Type u → Type v} [q : QPF F] (a : (QPF.P F).A) (f : (QPF.P F).B a → (QPF.P F).W) (a' : (QPF.P F).A)
(f' : (QPF.P F).B a' → (QPF.P F).W), QPF.abs ⟨a, f⟩ = QPF.abs ⟨a', f'⟩ → QPF.Wequiv (WType.mk a f) (WType.mk a' f') |
_private.Mathlib.Analysis.CStarAlgebra.ApproximateUnit.0.Set.InvOn.one_sub_one_add_inv._simp_1_1 | Mathlib.Analysis.CStarAlgebra.ApproximateUnit | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False |
Lean.Parser.Error.mk.sizeOf_spec | Lean.Parser.Types | ∀ (unexpectedTk : Lean.Syntax) (unexpected : String) (expected : List String),
sizeOf { unexpectedTk := unexpectedTk, unexpected := unexpected, expected := expected } =
1 + sizeOf unexpectedTk + sizeOf unexpected + sizeOf expected |
_private.Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme.0.AlgebraicGeometry.Scheme.instFullOppositeIdealSheafDataOverSubschemeFunctor._simp_2 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (h : X = Y),
CategoryTheory.IsIso (CategoryTheory.eqToHom h) = True |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.throw_ExceptT._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) |
Set.Icc.coe_nonneg | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] (x : ↑(Set.Icc 0 1)), 0 ≤ ↑x |
Matrix.single_apply_of_col_ne | Mathlib.Data.Matrix.Basis | ∀ {m : Type u_2} {n : Type u_3} {α : Type u_7} [inst : DecidableEq m] [inst_1 : DecidableEq n] [inst_2 : Zero α]
(i i' : m) {j j' : n}, j ≠ j' → ∀ (a : α), Matrix.single i j a i' j' = 0 |
isPreirreducible_singleton | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X}, IsPreirreducible {x} |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._proof_53 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r₀ r r' : ℤ),
autoParam (r + 1 = r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_47 →
autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_49 → r₀ ≤ r' |
continuousOn_stereoToFun | Mathlib.Geometry.Manifold.Instances.Sphere | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {v : E},
ContinuousOn (stereoToFun v) {x | ((innerSL ℝ) v) x ≠ 1} |
CategoryTheory.Oplax.OplaxTrans.Modification.noConfusion | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {P : Sort u} →
{B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.OplaxFunctor B C} →
{η θ : F ⟶ G} →
{t : CategoryTheory.Oplax.OplaxTrans.Modification η θ} →
{B' : Type u₁} →
{inst' : CategoryTheory.Bicategory B'} →
{C' : Type u₂} →
{inst'_1 : CategoryTheory.Bicategory C'} →
{F' G' : CategoryTheory.OplaxFunctor B' C'} →
{η' θ' : F' ⟶ G'} →
{t' : CategoryTheory.Oplax.OplaxTrans.Modification η' θ'} →
B = B' →
inst ≍ inst' →
C = C' →
inst_1 ≍ inst'_1 →
F ≍ F' →
G ≍ G' →
η ≍ η' →
θ ≍ θ' →
t ≍ t' →
CategoryTheory.Oplax.OplaxTrans.Modification.noConfusionType P t t' |
Lean.Data.Trie.empty | Lean.Data.Trie | {α : Type} → Lean.Data.Trie α |
Lean.Meta.Grind.Arith.CommRing.RingM.Context.rec | Lean.Meta.Tactic.Grind.Arith.CommRing.RingM | {motive : Lean.Meta.Grind.Arith.CommRing.RingM.Context → Sort u} →
((ringId : ℕ) → (checkCoeffDvd : Bool) → motive { ringId := ringId, checkCoeffDvd := checkCoeffDvd }) →
(t : Lean.Meta.Grind.Arith.CommRing.RingM.Context) → motive t |
Real.sqrt_inj._simp_1 | Mathlib.Data.Real.Sqrt | ∀ {x y : ℝ}, 0 ≤ x → 0 ≤ y → (√x = √y) = (x = y) |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.performRatAdd | Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation | {n : ℕ} →
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n →
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n →
Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) →
Array ℕ → Array (ℕ × Array ℕ) → Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n × Bool |
Aesop.RuleTacDescr.cases.noConfusion | Aesop.RuleTac.Descr | {P : Sort u} →
{target : Aesop.CasesTarget} →
{md : Lean.Meta.TransparencyMode} →
{isRecursiveType : Bool} →
{ctorNames : Array Aesop.CtorNames} →
{target' : Aesop.CasesTarget} →
{md' : Lean.Meta.TransparencyMode} →
{isRecursiveType' : Bool} →
{ctorNames' : Array Aesop.CtorNames} →
Aesop.RuleTacDescr.cases target md isRecursiveType ctorNames =
Aesop.RuleTacDescr.cases target' md' isRecursiveType' ctorNames' →
(target = target' → md = md' → isRecursiveType = isRecursiveType' → ctorNames = ctorNames' → P) → P |
CategoryTheory.ObjectProperty.InheritedFromSource.instMin | Mathlib.CategoryTheory.ObjectProperty.InheritedFromHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P P' : CategoryTheory.ObjectProperty C)
(Q : CategoryTheory.MorphismProperty C) [P.InheritedFromSource Q] [P'.InheritedFromSource Q],
(P ⊓ P').InheritedFromSource Q |
Vector.set | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → Vector α n → (i : ℕ) → α → autoParam (i < n) Vector.set._auto_1 → Vector α n |
_private.Mathlib.Probability.Distributions.Fernique.0.ProbabilityTheory.exists_integrable_exp_sq_of_map_rotation_eq_self_of_isProbabilityMeasure._simp_1_2 | Mathlib.Probability.Distributions.Fernique | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i |
CategoryTheory.Cat.freeRefl_map | Mathlib.CategoryTheory.Category.ReflQuiv | ∀ {X Y : CategoryTheory.ReflQuiv} (F : X ⟶ Y),
CategoryTheory.Cat.freeRefl.map F = (CategoryTheory.Cat.freeReflMap F).toCatHom |
CategoryTheory.MorphismProperty.equivalenceLeftFractionRel | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (W : CategoryTheory.MorphismProperty C)
[W.HasLeftCalculusOfFractions] (X Y : C), Equivalence CategoryTheory.MorphismProperty.LeftFractionRel |
ConvexSpace.noConfusion | Mathlib.LinearAlgebra.ConvexSpace | {P : Sort u_1} →
{R : Type u} →
{M : Type v} →
{inst : PartialOrder R} →
{inst_1 : Semiring R} →
{inst_2 : IsStrictOrderedRing R} →
{t : ConvexSpace R M} →
{R' : Type u} →
{M' : Type v} →
{inst' : PartialOrder R'} →
{inst'_1 : Semiring R'} →
{inst'_2 : IsStrictOrderedRing R'} →
{t' : ConvexSpace R' M'} →
R = R' →
M = M' →
inst ≍ inst' →
inst_1 ≍ inst'_1 → inst_2 ≍ inst'_2 → t ≍ t' → ConvexSpace.noConfusionType P t t' |
instInvInterval | Mathlib.Algebra.Order.Interval.Basic | {α : Type u_2} → [inst : CommGroup α] → [inst_1 : PartialOrder α] → [IsOrderedMonoid α] → Inv (Interval α) |
Lean.Lsp.TextDocumentSyncOptions.rec | Lean.Data.Lsp.TextSync | {motive : Lean.Lsp.TextDocumentSyncOptions → Sort u} →
((openClose : Bool) →
(change : Lean.Lsp.TextDocumentSyncKind) →
(willSave willSaveWaitUntil : Bool) →
(save? : Option Lean.Lsp.SaveOptions) →
motive
{ openClose := openClose, change := change, willSave := willSave, willSaveWaitUntil := willSaveWaitUntil,
save? := save? }) →
(t : Lean.Lsp.TextDocumentSyncOptions) → motive t |
Std.Internal.List.containsKey_iff_exists | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [PartialEquivBEq α] {l : List ((a : α) × β a)} {a : α},
Std.Internal.List.containsKey a l = true ↔ ∃ a' ∈ Std.Internal.List.keys l, (a == a') = true |
QuadraticModuleCat.instMonoidalCategory.tensorHom | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | {R : Type u} →
[inst : CommRing R] →
[inst_1 : Invertible 2] →
{W X Y Z : QuadraticModuleCat R} →
(W ⟶ X) →
(Y ⟶ Z) →
(QuadraticModuleCat.instMonoidalCategory.tensorObj W Y ⟶
QuadraticModuleCat.instMonoidalCategory.tensorObj X Z) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.