name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Cycle.support_formPerm | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (s : Cycle α) (h : s.Nodup),
s.Nontrivial → (s.formPerm h).support = s.toFinset | true |
right_iff_ite_iff | Init.PropLemmas | ∀ {p : Prop} [inst : Decidable p] {x y : Prop}, (y ↔ if p then x else y) ↔ p → y = x | true |
CategoryTheory.TwistShiftData.z_zero_right | Mathlib.CategoryTheory.Shift.Twist | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type w} [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (t : CategoryTheory.TwistShiftData C A) (a : A), t.z a 0 = 1 | true |
exists_smooth_forall_mem_convex_of_local_const | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {F : Type uF} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {H : Type uH} [inst_4 : TopologicalSpace H] (I : ModelWithCorners ℝ E H) {M : Type uM}
[inst_5 : TopologicalSpace M] [inst_6 : ChartedSpace H M] [FiniteDimensional ℝ E] [IsManifold I (↑⊤) M]
[SigmaCompactSpace M] [T2Space M] {t : M → Set F} {n : ℕ∞},
(∀ (x : M), Convex ℝ (t x)) → (∀ (x : M), ∃ c, ∀ᶠ (y : M) in nhds x, c ∈ t y) → ∃ g, ∀ (x : M), g x ∈ t x | true |
isPreconnected_iff_subset_of_fully_disjoint_closed | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α},
IsClosed s → (IsPreconnected s ↔ ∀ (u v : Set α), IsClosed u → IsClosed v → s ⊆ u ∪ v → Disjoint u v → s ⊆ u ∨ s ⊆ v) | true |
Submodule.rank_quotient_add_rank | Mathlib.LinearAlgebra.Dimension.RankNullity | ∀ {R : Type u_1} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[HasRankNullity.{u, u_1} R] (N : Submodule R M), Module.rank R (M ⧸ N) + Module.rank R ↥N = Module.rank R M | true |
FundamentalGroup.map | Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] → (f : C(X, Y)) → (x : X) → FundamentalGroup X x →* FundamentalGroup Y (f x) | true |
_private.Mathlib.Topology.MetricSpace.Thickening.0.Metric.eventually_notMem_cthickening_of_infEDist_pos._simp_1_2 | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | false |
Lean.Meta.Grind.MBTC.Context.mk.noConfusion | Lean.Meta.Tactic.Grind.MBTC | {P : Sort u} →
{isInterpreted hasTheoryVar : Lean.Expr → Lean.Meta.Grind.GoalM Bool} →
{eqAssignment : Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Bool} →
{isInterpreted' hasTheoryVar' : Lean.Expr → Lean.Meta.Grind.GoalM Bool} →
{eqAssignment' : Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Bool} →
{ isInterpreted := isInterpreted, hasTheoryVar := hasTheoryVar, eqAssignment := eqAssignment } =
{ isInterpreted := isInterpreted', hasTheoryVar := hasTheoryVar', eqAssignment := eqAssignment' } →
(isInterpreted = isInterpreted' → hasTheoryVar = hasTheoryVar' → eqAssignment = eqAssignment' → P) → P | false |
Submonoid.LocalizationMap.mk'_eq_zero_iff | Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoidWithZero N]
(f : S.LocalizationMap N) (m : M) (s : ↥S), f.mk' m s = 0 ↔ ∃ s, ↑s * m = 0 | true |
_private.Mathlib.RingTheory.Ideal.Operations.0.Submodule.smul_le_span._simp_1_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] (s : Set R), Ideal.span s = s • ⊤ | false |
Encodable.chooseX.match_1 | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} {p : α → Prop} (motive : (∃ x, p x) → Prop) (h : ∃ x, p x), (∀ (w : α) (pw : p w), motive ⋯) → motive h | false |
_private.Mathlib.Combinatorics.SimpleGraph.Prod.0.SimpleGraph.reachable_boxProd.match_1_3 | Mathlib.Combinatorics.SimpleGraph.Prod | ∀ {α : Type u_1} {β : Type u_2} {G : SimpleGraph α} {H : SimpleGraph β} {x y : α × β}
(motive : G.Reachable x.1 y.1 ∧ H.Reachable x.2 y.2 → Prop) (h : G.Reachable x.1 y.1 ∧ H.Reachable x.2 y.2),
(∀ (w₁ : G.Walk x.1 y.1) (w₂ : H.Walk x.2 y.2), motive ⋯) → motive h | false |
PrimeSpectrum.BasicConstructibleSetData.recOn | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | {R : Type u_1} →
{motive : PrimeSpectrum.BasicConstructibleSetData R → Sort u} →
(t : PrimeSpectrum.BasicConstructibleSetData R) →
((f : R) → (n : ℕ) → (g : Fin n → R) → motive { f := f, n := n, g := g }) → motive t | false |
PolynomialLaw.toFun'_eq_of_inclusion | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u} [inst : CommSemiring R] {M : Type u_1} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {S : Type v} [inst_5 : CommSemiring S] [inst_6 : Algebra R S]
(f : M →ₚₗ[R] N) {A : Type u} [inst_7 : CommSemiring A] [inst_8 : Algebra R A] {φ : A →ₐ[R] S}
(p : TensorProduct R A M) {B : Type u} [inst_9 : CommSemiring B] [inst_10 : Algebra R B] (q : TensorProduct R B M)
{ψ : B →ₐ[R] S} (h : φ.range ≤ ψ.range),
(LinearMap.rTensor M ((Subalgebra.inclusion h).comp φ.rangeRestrict).toLinearMap) p =
(LinearMap.rTensor M ψ.rangeRestrict.toLinearMap) q →
(LinearMap.rTensor N φ.toLinearMap) (f.toFun' A p) = (LinearMap.rTensor N ψ.toLinearMap) (f.toFun' B q) | true |
List.SublistForall₂.recOn | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop}
{motive : (a : List α) → (a_1 : List β) → List.SublistForall₂ R a a_1 → Prop} {a : List α} {a_1 : List β}
(t : List.SublistForall₂ R a a_1),
(∀ {l : List β}, motive [] l ⋯) →
(∀ {a₁ : α} {a₂ : β} {l₁ : List α} {l₂ : List β} (a : R a₁ a₂) (a_2 : List.SublistForall₂ R l₁ l₂),
motive l₁ l₂ a_2 → motive (a₁ :: l₁) (a₂ :: l₂) ⋯) →
(∀ {a : β} {l₁ : List α} {l₂ : List β} (a_2 : List.SublistForall₂ R l₁ l₂),
motive l₁ l₂ a_2 → motive l₁ (a :: l₂) ⋯) →
motive a a_1 t | false |
Monoid.PushoutI.NormalWord.head | Mathlib.GroupTheory.PushoutI | {ι : Type u_1} →
{G : ι → Type u_2} →
{H : Type u_3} →
[inst : (i : ι) → Group (G i)] →
[inst_1 : Group H] →
{φ : (i : ι) → H →* G i} → {d : Monoid.PushoutI.NormalWord.Transversal φ} → Monoid.PushoutI.NormalWord d → H | true |
Std.Time.TimeZone.instInhabitedUTLocal.default | Std.Time.Zoned.ZoneRules | Std.Time.TimeZone.UTLocal | true |
Lean.Lsp.DidCloseTextDocumentParams | Lean.Data.Lsp.TextSync | Type | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergence.0.tendstoUniformlyOn_singleton_iff_tendsto._simp_1_3 | Mathlib.Topology.UniformSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l₁ : Filter α} {l₂ : Filter β},
Filter.Tendsto f l₁ l₂ = ∀ s ∈ l₂, f ⁻¹' s ∈ l₁ | false |
_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.Score.mk.sizeOf_spec | Lean.Data.FuzzyMatching | ∀ (inner : Int16), sizeOf { inner := inner } = 1 + sizeOf inner | true |
_private.Mathlib.RingTheory.IntegralClosure.IntegrallyClosed.0.Associated.pow_iff._simp_1_1 | Mathlib.RingTheory.IntegralClosure.IntegrallyClosed | ∀ {M : Type u_1} [inst : MonoidWithZero M] [IsLeftCancelMulZero M] {a b : M}, Associated a b = (a ∣ b ∧ b ∣ a) | false |
LibraryNote.norm_num_lemma_function_equality | Mathlib.Tactic.NormNum.Basic | Batteries.Util.LibraryNote | true |
AffineSubspace.instCompleteLattice._proof_2 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] (x x_1 : AffineSubspace k P), ↑x ⊆ ↑(affineSpan k (↑x ∪ ↑x_1)) | false |
padicNormE.defn | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (f : PadicSeq p) {ε : ℚ},
0 < ε → ∃ N, ∀ i ≥ N, padicNormE (Padic.mk f - ↑(↑f i)) < ε | true |
Lean.Grind.CommRing.Expr.denote_toPoly | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.CommRing α] (ctx : Lean.Grind.CommRing.Context α) (e : Lean.Grind.CommRing.Expr),
Lean.Grind.CommRing.Poly.denote ctx e.toPoly = Lean.Grind.CommRing.Expr.denote ctx e | true |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreCommRing.injEq | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ (a b : Lean.Expr) (ra rb : Lean.Grind.CommRing.Expr) (p : Lean.Grind.CommRing.Poly)
(lhs' : Lean.Meta.Grind.Arith.Linear.LinExpr) (a_1 b_1 : Lean.Expr) (ra_1 rb_1 : Lean.Grind.CommRing.Expr)
(p_1 : Lean.Grind.CommRing.Poly) (lhs'_1 : Lean.Meta.Grind.Arith.Linear.LinExpr),
(Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreCommRing a b ra rb p lhs' =
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreCommRing a_1 b_1 ra_1 rb_1 p_1 lhs'_1) =
(a = a_1 ∧ b = b_1 ∧ ra = ra_1 ∧ rb = rb_1 ∧ p = p_1 ∧ lhs' = lhs'_1) | true |
Complex.HadamardThreeLines.sSupNormIm | Mathlib.Analysis.Complex.Hadamard | {E : Type u_1} → [NormedAddCommGroup E] → (ℂ → E) → ℝ → ℝ | true |
NonUnitalSubalgebra.toNonUnitalSubsemiring'._proof_2 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
(S T : NonUnitalSubalgebra R A), S.toNonUnitalSubsemiring = T.toNonUnitalSubsemiring → S = T | false |
_private.Lean.Compiler.LCNF.ToMono.0.Lean.Compiler.LCNF.LetValue.toMono.match_3 | Lean.Compiler.LCNF.ToMono | (motive : Lean.Compiler.LCNF.DeclValue Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(x : Lean.Compiler.LCNF.DeclValue Lean.Compiler.LCNF.Purity.pure) →
((resultFVar : Lean.FVarId) →
(binderName : Lean.Name) →
(type : Lean.Expr) →
(callName : Lean.Name) →
(us : List Lean.Level) →
(callArgs : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) →
(retFVar : Lean.FVarId) →
motive
(Lean.Compiler.LCNF.DeclValue.code
(Lean.Compiler.LCNF.Code.let
{ fvarId := resultFVar, binderName := binderName, type := type,
value := Lean.Compiler.LCNF.LetValue.const callName us callArgs ⋯ }
(Lean.Compiler.LCNF.Code.return retFVar)))) →
((x : Lean.Compiler.LCNF.DeclValue Lean.Compiler.LCNF.Purity.pure) → motive x) → motive x | false |
FirstOrder.Language.orderLHom_onRelation | Mathlib.ModelTheory.Order | ∀ (L : FirstOrder.Language) [inst : L.IsOrdered] (x : ℕ) (x_1 : FirstOrder.Language.order.Relations x),
L.orderLHom.onRelation x_1 =
match x, x_1 with
| .(2), FirstOrder.Language.orderRel.le => FirstOrder.Language.leSymb | true |
_private.Mathlib.Data.Fin.Tuple.Basic.0.Fin.findX._proof_13 | Mathlib.Data.Fin.Tuple.Basic | ∀ {n : ℕ} (p : Fin n → Prop) (h : ∃ k, p k) (m : ℕ),
(∀ (j : ℕ) (hm : j < n - (m + 1)), ¬p ⟨j, ⋯⟩) → ¬p ⟨n - (m + 1), ⋯⟩ → ∀ (j_1 : ℕ) (h_1 : j_1 < n - m), ¬p ⟨j_1, ⋯⟩ | false |
CategoryTheory.Limits.Cofork.ofCocone | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C} →
CategoryTheory.Limits.Cocone F →
CategoryTheory.Limits.Cofork (F.map CategoryTheory.Limits.WalkingParallelPairHom.left)
(F.map CategoryTheory.Limits.WalkingParallelPairHom.right) | true |
CategoryTheory.Ind.yoneda.fullyFaithful | Mathlib.CategoryTheory.Limits.Indization.Category | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Ind.yoneda.FullyFaithful | true |
UniformConvergenceCLM.sub_apply | Mathlib.Topology.Algebra.Module.StrongTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_3}
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : TopologicalSpace F] [inst_8 : IsTopologicalAddGroup F]
(𝔖 : Set (Set E)) (f g : UniformConvergenceCLM σ F 𝔖) (x : E), (f - g) x = f x - g x | true |
_private.Std.Data.DHashMap.Basic.0.Std.DHashMap.Const.insertManyIfNewUnit._proof_2 | Std.Data.DHashMap.Basic | ∀ {α : Type u_1} {x : BEq α} {x_1 : Hashable α} {ρ : Type u_2} [inst : ForIn Id ρ α] (m : Std.DHashMap α fun x => Unit)
(l : ρ), (↑↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit ⟨m.inner, ⋯⟩ l)).WF | false |
Std.Sat.AIG.toGraphviz.toGraphvizString.match_1 | Std.Sat.AIG.Basic | {α : Type} →
(motive : Std.Sat.AIG.Decl α → Sort u_1) →
(x : Std.Sat.AIG.Decl α) →
(Unit → motive Std.Sat.AIG.Decl.false) →
((i : α) → motive (Std.Sat.AIG.Decl.atom i)) →
((l r : Std.Sat.AIG.Fanin) → motive (Std.Sat.AIG.Decl.gate l r)) → motive x | false |
Int.dvd_zero._simp_1 | Init.Data.Int.DivMod.Bootstrap | ∀ (n : ℤ), (n ∣ 0) = True | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF._proof_23 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ),
∀ upper < aig.decls.size,
∀ (state : Std.Sat.AIG.toCNF.State✝ aig),
(Std.Sat.AIG.toCNF.Cache.marks✝ (Std.Sat.AIG.toCNF.State.cache✝ state)).size = aig.decls.size →
¬upper < (Std.Sat.AIG.toCNF.Cache.marks✝¹ (Std.Sat.AIG.toCNF.State.cache✝¹ state)).size → False | false |
ProbabilityTheory.IsMeasurableRatCDF.measurable_stieltjesFunction | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} {f : α → ℚ → ℝ} [inst : MeasurableSpace α] (hf : ProbabilityTheory.IsMeasurableRatCDF f) (x : ℝ),
Measurable fun a => ↑(hf.stieltjesFunction a) x | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get_insertIfNew._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
_private.Init.Data.Format.Basic.0.Std.Format.WorkGroup.fla | Init.Data.Format.Basic | Std.Format.WorkGroup✝ → Std.Format.FlattenAllowability | true |
String.codepointPosToUtf8PosFrom | Lean.Data.Lsp.Utf16 | String → String.Pos.Raw → ℕ → String.Pos.Raw | true |
CategoryTheory.Subfunctor.Subpresheaf.image_iSup | Mathlib.CategoryTheory.Subfunctor.Image | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F F' : CategoryTheory.Functor C (Type w)} {ι : Type u_1}
(G : ι → CategoryTheory.Subfunctor F) (f : F ⟶ F'), (⨆ i, G i).image f = ⨆ i, (G i).image f | true |
Holor.cprankMax_1 | Mathlib.Data.Holor | ∀ {α : Type} {ds : List ℕ} [inst : Mul α] [inst_1 : AddMonoid α] {x : Holor α ds}, x.CPRankMax1 → Holor.CPRankMax 1 x | true |
Set.op_smul_set_mul_eq_mul_smul_set | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Semigroup α] (a : α) (s t : Set α), MulOpposite.op a • s * t = s * a • t | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsProperLinearSet.add_floor_neg_toNat_sum_eq | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_3} {s : Set (ι → ℕ)} (hs : IsProperLinearSet s) [inst : Finite ι] (x : ι → ℕ),
x + ∑ i, (-IsProperLinearSet.floor✝ hs x i).toNat • ↑i =
IsProperLinearSet.fract✝ hs x + ∑ i, (IsProperLinearSet.floor✝¹ hs x i).toNat • ↑i | true |
Concept.ofIsIntent._proof_1 | Mathlib.Order.Concept | ∀ {α : Type u_1} {β : Type u_2} (r : α → β → Prop) (t : Set β), lowerPolar r t = lowerPolar r t | false |
CategoryTheory.IsFiltered.isConnected | Mathlib.CategoryTheory.Filtered.Connected | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C], CategoryTheory.IsConnected C | true |
isClopen_iInter | Mathlib.Topology.AlexandrovDiscrete | ∀ {ι : Sort u_1} {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α] {f : ι → Set α},
(∀ (i : ι), IsClopen (f i)) → IsClopen (⋂ i, f i) | true |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabOfNatCore._sparseCasesOn_1 | Lean.PrettyPrinter.Delaborator.Builtins | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | false |
matrixEquivTensor._proof_2 | Mathlib.RingTheory.MatrixAlgebra | ∀ (n : Type u_2) (R : Type u_1) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Fintype n] [inst_4 : DecidableEq n],
Function.RightInverse (MatrixEquivTensor.equiv n R A).invFun (MatrixEquivTensor.equiv n R A).toFun | false |
BitVec.mul_succ | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x * (y + 1#w) = x * y + x | true |
Equiv.IicFinsetSet._proof_2 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] (a : α),
Function.LeftInverse (fun b => ⟨↑b, ⋯⟩) fun b => ⟨↑b, ⋯⟩ | false |
nhdsWithin_extChartAt_target_eq_of_mem | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
{I : ModelWithCorners 𝕜 E H} [inst_5 : ChartedSpace H M] {x : M} {z : E},
z ∈ (extChartAt I x).target → nhdsWithin z (extChartAt I x).target = nhdsWithin z (Set.range ↑I) | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.existsRatHint_of_ratHintsExhaustive._proof_1_33 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound | ∀ (ratHints : Array (ℕ × Array ℕ)) (j : Fin (Array.map (fun x => x.1) ratHints).toList.length),
↑j < (Array.map (fun x => x.1) ratHints).size | false |
Std.Internal.List.getValue?_insertList | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l toInsert : List ((_ : α) × β)} {k : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.DistinctKeys toInsert →
Std.Internal.List.getValue? k (Std.Internal.List.insertList l toInsert) =
(Std.Internal.List.getValue? k toInsert).or (Std.Internal.List.getValue? k l) | true |
Algebra.norm | Mathlib.RingTheory.Norm.Defs | (R : Type u_1) → {S : Type u_2} → [inst : CommRing R] → [inst_1 : Ring S] → [Algebra R S] → S →* R | true |
HasFTaylorSeriesUpToOn.hasStrictFDerivAt | Mathlib.Analysis.Calculus.ContDiff.RCLike | ∀ {𝕂 : Type u_1} [inst : RCLike 𝕂] {E' : Type u_2} [inst_1 : NormedAddCommGroup E'] [inst_2 : NormedSpace 𝕂 E']
{F' : Type u_3} [inst_3 : NormedAddCommGroup F'] [inst_4 : NormedSpace 𝕂 F'] {n : WithTop ℕ∞} {s : Set E'}
{f : E' → F'} {x : E'} {p : E' → FormalMultilinearSeries 𝕂 E' F'},
HasFTaylorSeriesUpToOn n f p s →
n ≠ 0 → s ∈ nhds x → HasStrictFDerivAt f ((continuousMultilinearCurryFin1 𝕂 E' F') (p x 1)) x | true |
LinearEquiv.multilinearMapCongrRight.congr_simp | Mathlib.LinearAlgebra.Multilinear.Finsupp | ∀ {R : Type uR} (S : Type uS) {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} {M₃ : Type v₃} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : (i : ι) → Module R (M₁ i)] [inst_3 : AddCommMonoid M₂]
[inst_4 : Module R M₂] [inst_5 : Semiring S] [inst_6 : Module S M₂] [inst_7 : SMulCommClass R S M₂]
[inst_8 : AddCommMonoid M₃] [inst_9 : Module S M₃] [inst_10 : Module R M₃] [inst_11 : SMulCommClass R S M₃]
[inst_12 : LinearMap.CompatibleSMul M₂ M₃ S R] [inst_13 : LinearMap.CompatibleSMul M₃ M₂ S R] (g g_1 : M₂ ≃ₗ[R] M₃),
g = g_1 → LinearEquiv.multilinearMapCongrRight S g = LinearEquiv.multilinearMapCongrRight S g_1 | true |
RingCon.mk'._proof_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (c : RingCon R), ↑1 = ↑1 | false |
RingEquiv.piMulOpposite._proof_4 | Mathlib.Algebra.Ring.Equiv | ∀ {ι : Type u_1} (S : ι → Type u_2) [inst : (i : ι) → NonUnitalNonAssocSemiring (S i)] (x x_1 : ((i : ι) → S i)ᵐᵒᵖ),
(fun i => MulOpposite.op (MulOpposite.unop (x + x_1) i)) = fun i => MulOpposite.op (MulOpposite.unop (x + x_1) i) | false |
CategoryTheory.Dial.tensorUnit_rel | Mathlib.CategoryTheory.Dialectica.Monoidal | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C],
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Dial C)).rel = ⊤ | true |
Lean.Lsp.InlayHintParams.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} → {t t' : Lean.Lsp.InlayHintParams} → t = t' → Lean.Lsp.InlayHintParams.noConfusionType P t t' | false |
NNDist.mk.noConfusion | Mathlib.Topology.MetricSpace.Pseudo.Defs | {α : Type u_3} →
{P : Sort u} →
{nndist nndist' : α → α → NNReal} → { nndist := nndist } = { nndist := nndist' } → (nndist ≍ nndist' → P) → P | false |
Tropical.instAddCommSemigroupTropical._proof_2 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : LinearOrder R] (x x_1 : Tropical R), x + x_1 = x_1 + x | false |
threeGPFree_smul_set₀ | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ {α : Type u_2} [inst : CommMonoidWithZero α] [IsCancelMulZero α] [NoZeroDivisors α] {s : Set α} {a : α},
a ≠ 0 → (ThreeGPFree (a • s) ↔ ThreeGPFree s) | true |
ProbabilityTheory.Kernel.withDensity_zero' | Mathlib.Probability.Kernel.WithDensity | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (κ : ProbabilityTheory.Kernel α β)
[inst : ProbabilityTheory.IsSFiniteKernel κ], (κ.withDensity fun x x_1 => 0) = 0 | true |
Nat.Prime.dvd_primorial_iff | Mathlib.NumberTheory.Primorial | ∀ {p n : ℕ}, Nat.Prime p → (p ∣ primorial n ↔ p ≤ n) | true |
CategoryTheory.Limits.ConeMorphism.w_assoc | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {A B : CategoryTheory.Limits.Cone F} (self : CategoryTheory.Limits.ConeMorphism A B)
(j : J) {Z : C} (h : F.obj j ⟶ Z),
CategoryTheory.CategoryStruct.comp self.hom (CategoryTheory.CategoryStruct.comp (B.π.app j) h) =
CategoryTheory.CategoryStruct.comp (A.π.app j) h | true |
IsTop.not_isBot | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : PartialOrder α] {a : α} [Nontrivial α], IsTop a → ¬IsBot a | true |
bddOrd_dual_comp_forget_to_bipointed | Mathlib.Order.Category.BddOrd | BddOrd.dual.comp (CategoryTheory.forget₂ BddOrd Bipointed) =
(CategoryTheory.forget₂ BddOrd Bipointed).comp Bipointed.swap | true |
_private.Mathlib.Topology.Algebra.Group.OpenMapping.0.isOpenMap_smul_of_sigmaCompact._simp_1_1 | Mathlib.Topology.Algebra.Group.OpenMapping | ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
IsOpenMap f = ∀ (x : X), nhds (f x) ≤ Filter.map f (nhds x) | false |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.Stained.toFMVarId.match_1 | Mathlib.Tactic.Linter.FlexibleLinter | (motive : Option Lean.LocalDecl → Sort u_1) →
(x : Option Lean.LocalDecl) → (Unit → motive none) → ((decl : Lean.LocalDecl) → motive (some decl)) → motive x | false |
Algebra.GrothendieckAddGroup.lift | Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup | {M : Type u_1} →
{G : Type u_2} →
[inst : AddCommMonoid M] → [inst_1 : AddCommGroup G] → (M →+ G) ≃ (Algebra.GrothendieckAddGroup M →+ G) | true |
_private.Lean.Elab.DocString.0.Lean.Doc.fixupInline.match_3 | Lean.Elab.DocString | (motive : Option Lean.Doc.ElabLink✝ → Sort u_1) →
(x : Option Lean.Doc.ElabLink✝¹) →
((name : Lean.StrLit) → motive (some { name := name })) → ((x : Option Lean.Doc.ElabLink✝²) → motive x) → motive x | false |
CategoryTheory.PrelaxFunctor.id._proof_3 | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | ∀ (B : Type u_2) [inst : CategoryTheory.Bicategory B] {a b : B} {f g h : a ⟶ b} (η : f ⟶ g) (θ : g ⟶ h),
(CategoryTheory.PrelaxFunctorStruct.id B).map₂ (CategoryTheory.CategoryStruct.comp η θ) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.PrelaxFunctorStruct.id B).map₂ η)
((CategoryTheory.PrelaxFunctorStruct.id B).map₂ θ) | false |
Lean.Data.AC.EvalInformation.evalOp | Init.Data.AC | {α : Sort u} → {β : Sort v} → [self : Lean.Data.AC.EvalInformation α β] → α → β → β → β | true |
Matrix.ProjectiveSpecialLinearGroup | Mathlib.LinearAlgebra.Matrix.ProjectiveSpecialLinearGroup | (n : Type u) → [DecidableEq n] → [Fintype n] → (R : Type v) → [CommRing R] → Type (max (max u v) v u) | true |
instModuleQuotientAddSubgroupTorsion._proof_2 | Mathlib.GroupTheory.Torsion | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (a : R) (x y : M),
{ toAddSubmonoid := (AddCommGroup.torsion M).toAddSubmonoid, smul_mem' := ⋯ }.quotientRel x y →
(QuotientAddGroup.leftRel
{ toAddSubmonoid := (AddCommGroup.torsion M).toAddSubmonoid, smul_mem' := ⋯ }.toAddSubgroup)
(a • x) (a • y) | false |
ByteArray.findFinIdx?.loop | Init.Data.ByteArray.Basic | (a : ByteArray) → (UInt8 → Bool) → ℕ → Option (Fin a.size) | true |
PointedCone.map_id | Mathlib.Geometry.Convex.Cone.Pointed | ∀ {R : Type u_1} {E : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid E] [inst_4 : Module R E] (C : PointedCone R E), PointedCone.map LinearMap.id C = C | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.differentiable_set_subset_D._simp_1_5 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | false |
Plausible.TotalFunction.rec | Plausible.Functions | {α : Type u} →
{β : Type v} →
{motive : Plausible.TotalFunction α β → Sort u_1} →
((a : List ((_ : α) × β)) → (a_1 : β) → motive (Plausible.TotalFunction.withDefault a a_1)) →
(t : Plausible.TotalFunction α β) → motive t | false |
CategoryTheory.Functor.IsStronglyCocartesian.mk._flat_ctor | Mathlib.CategoryTheory.FiberedCategory.Cocartesian | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} {R S : 𝒮} {a b : 𝒳} {f : R ⟶ S} {φ : a ⟶ b} [toIsHomLift : p.IsHomLift f φ],
(∀ {b' : 𝒳} (g : S ⟶ p.obj b') (φ' : a ⟶ b') [p.IsHomLift (CategoryTheory.CategoryStruct.comp f g) φ'],
∃! χ, p.IsHomLift g χ ∧ CategoryTheory.CategoryStruct.comp φ χ = φ') →
p.IsStronglyCocartesian f φ | false |
_private.Init.Data.Vector.Perm.0.Vector.swap_perm._simp_1_2 | Init.Data.Vector.Perm | ∀ {α : Type u_1} {n : ℕ} {as bs : Vector α n}, as.Perm bs = as.toList.Perm bs.toList | false |
Mathlib.Tactic.Push.pullStep | Mathlib.Tactic.Push | Mathlib.Tactic.Push.Head → Lean.Meta.Simp.Simproc | true |
TopCat.const._proof_2 | Mathlib.Topology.Category.TopCat.Basic | ∀ {X Y : TopCat} (y : ↑Y), Continuous fun x => y | false |
Function.locallyFinsuppWithin.restrictMonoidHom_apply | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddCommGroup Y] {V : Set X}
(D : Function.locallyFinsuppWithin U Y) (h : V ⊆ U),
(Function.locallyFinsuppWithin.restrictMonoidHom h) D = D.restrict h | true |
_private.Lean.Meta.Sym.Simp.Rewrite.0.Lean.Meta.Sym.Simp.Theorem.rewrite._sparseCasesOn_4 | Lean.Meta.Sym.Simp.Rewrite | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | false |
_private.Lean.Elab.DocString.0.Lean.Doc.findShadowedNames.match_3 | Lean.Elab.DocString | {α : Type} →
(motive : Lean.Name × α → Sort u_1) →
(x : Lean.Name × α) → ((fullName : Lean.Name) → (snd : α) → motive (fullName, snd)) → motive x | false |
FiberPrebundle.pretrivializationAt | Mathlib.Topology.FiberBundle.Basic | {B : Type u_2} →
{F : Type u_3} →
{E : B → Type u_5} →
[inst : TopologicalSpace B] →
[inst_1 : TopologicalSpace F] →
[inst_2 : (x : B) → TopologicalSpace (E x)] →
FiberPrebundle F E → B → Bundle.Pretrivialization F Bundle.TotalSpace.proj | true |
Aesop.ExtResult._sizeOf_1 | Aesop.Util.Tactic.Ext | Aesop.ExtResult → ℕ | false |
UInt64.toUInt16_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a.toUInt16 < b.toUInt16 ↔ a % 65536 < b % 65536 | true |
CategoryTheory.regularTopology.EqualizerCondition.bijective_mapToEqualizer_pullback | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.Functor Cᵒᵖ (Type u_4)},
CategoryTheory.regularTopology.EqualizerCondition P →
∀ {X B : C} (π : X ⟶ B) [CategoryTheory.EffectiveEpi π] [inst_2 : CategoryTheory.Limits.HasPullback π π],
Function.Bijective
(CategoryTheory.regularTopology.mapToEqualizer P π (CategoryTheory.Limits.pullback.fst π π)
(CategoryTheory.Limits.pullback.snd π π) ⋯) | true |
Nonneg.conditionallyCompleteLinearOrder._proof_10 | Mathlib.Algebra.Order.Nonneg.Lattice | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrder α] {a : α} (this : Inhabited ↑(Set.Ici a)),
autoParam (∀ (a_1 b : { x // a ≤ x }), compare a_1 b = compareOfLessAndEq a_1 b)
ConditionallyCompleteLinearOrder.compare_eq_compareOfLessAndEq._autoParam | false |
collinear_empty | Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional | ∀ (k : Type u_1) {V : Type u_2} (P : Type u_3) [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P], Collinear k ∅ | true |
Lean.Lsp.ReferenceParams.context | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ReferenceParams → Lean.Lsp.ReferenceContext | true |
CategoryTheory.Abelian.extFunctor_obj | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] (n : ℕ) (X : Cᵒᵖ),
(CategoryTheory.Abelian.extFunctor n).obj X = CategoryTheory.Abelian.extFunctorObj (Opposite.unop X) n | true |
_private.Mathlib.Algebra.Homology.Embedding.CochainComplex.0.CochainComplex.quasiIso_truncGEMap_iff._proof_1_1 | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ (n : ℤ) (i : ℕ), n ≤ n + ↑i | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.