name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
StarAlgHom.copy._proof_3 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Star A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : Star B] (f : A →⋆ₐ[R] B) (f' : A → B),
f' = ⇑f → f' 0 = 0 |
Lean.Elab.Term.Do.Code.reassign.inj | Lean.Elab.Do.Legacy | ∀ {xs : Array Lean.Elab.Term.Do.Var} {doElem : Lean.Syntax} {k : Lean.Elab.Term.Do.Code}
{xs_1 : Array Lean.Elab.Term.Do.Var} {doElem_1 : Lean.Syntax} {k_1 : Lean.Elab.Term.Do.Code},
Lean.Elab.Term.Do.Code.reassign xs doElem k = Lean.Elab.Term.Do.Code.reassign xs_1 doElem_1 k_1 →
xs = xs_1 ∧ doElem = doElem_1 ∧ k = k_1 |
Std.DTreeMap.Internal.Impl.ExplorationStep.lt.injEq | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {k : α → Ordering} (a : α) (a_1 : k a = Ordering.lt) (a_2 : β a)
(a_3 : List ((a : α) × β a)) (a_4 : α) (a_5 : k a_4 = Ordering.lt) (a_6 : β a_4) (a_7 : List ((a : α) × β a)),
(Std.DTreeMap.Internal.Impl.ExplorationStep.lt a a_1 a_2 a_3 =
Std.DTreeMap.Internal.Impl.ExplorationStep.lt a_4 a_5 a_6 a_7) =
(a = a_4 ∧ a_2 ≍ a_6 ∧ a_3 = a_7) |
IsOrderedAddMonoid.toIsOrderedCancelAddMonoid | Mathlib.Algebra.Order.Group.Defs | ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α], IsOrderedCancelAddMonoid α |
Std.Format.nest.elim | Init.Data.Format.Basic | {motive : Std.Format → Sort u} →
(t : Std.Format) → t.ctorIdx = 4 → ((indent : ℤ) → (f : Std.Format) → motive (Std.Format.nest indent f)) → motive t |
Denumerable.ofEncodableOfInfinite._proof_1 | Mathlib.Logic.Denumerable | ∀ (α : Type u_1) [inst : Encodable α] [Infinite α], Infinite ↑(Set.range Encodable.encode) |
Std.DTreeMap.Raw.partition.eq_1 | Std.Data.DTreeMap.Raw.WF | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} (f : (a : α) → β a → Bool) (t : Std.DTreeMap.Raw α β cmp),
Std.DTreeMap.Raw.partition f t =
Std.DTreeMap.Raw.foldl
(fun x a b =>
match x with
| (l, r) => if f a b = true then (l.insert a b, r) else (l, r.insert a b))
(∅, ∅) t |
InnerProductSpace.gramSchmidt_ne_zero_coe | Mathlib.Analysis.InnerProductSpace.GramSchmidtOrtho | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_3} [inst_3 : LinearOrder ι] [inst_4 : LocallyFiniteOrderBot ι] [inst_5 : WellFoundedLT ι] {f : ι → E}
(n : ι), LinearIndependent 𝕜 (f ∘ Subtype.val) → InnerProductSpace.gramSchmidt 𝕜 f n ≠ 0 |
Affine.Simplex.circumcenter_eq_affineCombination_of_pointsWithCircumcenter | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} (s : Affine.Simplex ℝ P n),
s.circumcenter =
(Finset.affineCombination ℝ Finset.univ s.pointsWithCircumcenter)
(Affine.Simplex.circumcenterWeightsWithCircumcenter n) |
cfcₙ_neg | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommRing R] [inst_1 : Nontrivial R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalRing R] [inst_5 : ContinuousStar R] [inst_6 : TopologicalSpace A]
[inst_7 : NonUnitalRing A] [inst_8 : StarRing A] [inst_9 : Module R A] [inst_10 : IsScalarTower R A A]
[inst_11 : SMulCommClass R A A] [inst_12 : NonUnitalContinuousFunctionalCalculus R A p] (f : R → R) (a : A),
cfcₙ (fun x => -f x) a = -cfcₙ f a |
Set.notMem_of_notMem_sUnion | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {x : α} {t : Set α} {S : Set (Set α)}, x ∉ ⋃₀ S → t ∈ S → x ∉ t |
CategoryTheory.Limits.HasCountableLimits.recOn | Mathlib.CategoryTheory.Limits.Shapes.Countable | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{motive : CategoryTheory.Limits.HasCountableLimits C → Sort u} →
(t : CategoryTheory.Limits.HasCountableLimits C) →
((out :
∀ (J : Type) [inst_1 : CategoryTheory.SmallCategory J] [CategoryTheory.CountableCategory J],
CategoryTheory.Limits.HasLimitsOfShape J C) →
motive ⋯) →
motive t |
USize.and_le_left | Init.Data.UInt.Bitwise | ∀ {a b : USize}, a &&& b ≤ a |
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 |
right_iff_ite_iff | Init.PropLemmas | ∀ {p : Prop} [inst : Decidable p] {x y : Prop}, (y ↔ if p then x else y) ↔ p → y = x |
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 |
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 |
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) |
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 |
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) |
_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) |
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 |
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 |
_private.Mathlib.RingTheory.Ideal.Operations.0.Submodule.smul_le_span._simp_1_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : CommSemiring R] (s : Set R), Ideal.span s = s • ⊤ |
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 |
_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 |
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 |
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) |
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 |
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 |
_private.Mathlib.Computability.TMToPartrec.0.Turing.PartrecToTM2.trStmts₁_trans._simp_1_12 | Mathlib.Computability.TMToPartrec | ∀ {a b c : Prop}, (a ∨ b → c) = ((a → c) ∧ (b → c)) |
Std.Time.TimeZone.instInhabitedUTLocal.default | Std.Time.Zoned.ZoneRules | Std.Time.TimeZone.UTLocal |
Lean.Lsp.DidCloseTextDocumentParams | Lean.Data.Lsp.TextSync | Type |
_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₁ |
_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.Score.mk.sizeOf_spec | Lean.Data.FuzzyMatching | ∀ (inner : Int16), sizeOf { inner := inner } = 1 + sizeOf inner |
_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) |
LibraryNote.norm_num_lemma_function_equality | Mathlib.Tactic.NormNum.Basic | Batteries.Util.LibraryNote |
AffineSubspace.instCompleteLattice._proof_2 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_2} {V : Type u_3} {P : Type u_1} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] (S_1 : Set (AffineSubspace k P)) (s₁ : AffineSubspace k P),
(∀ b ∈ S_1, s₁ ≤ b) → s₁ ≤ { carrier := ⋂ s' ∈ S_1, ↑s', smul_vsub_vadd_mem := ⋯ } |
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)) < ε |
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 |
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) |
Complex.HadamardThreeLines.sSupNormIm | Mathlib.Analysis.Complex.Hadamard | {E : Type u_1} → [NormedAddCommGroup E] → (ℂ → E) → ℝ → ℝ |
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 |
_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 |
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 |
_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, ⋯⟩ |
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) |
CategoryTheory.Ind.yoneda.fullyFaithful | Mathlib.CategoryTheory.Limits.Indization.Category | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Ind.yoneda.FullyFaithful |
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 |
_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 |
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 |
Int.dvd_zero._simp_1 | Init.Data.Int.DivMod.Bootstrap | ∀ (n : ℤ), (n ∣ 0) = True |
_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 |
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 |
_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) |
_private.Init.Data.Format.Basic.0.Std.Format.WorkGroup.fla | Init.Data.Format.Basic | Std.Format.WorkGroup✝ → Std.Format.FlattenAllowability |
String.codepointPosToUtf8PosFrom | Lean.Data.Lsp.Utf16 | String → String.Pos.Raw → ℕ → String.Pos.Raw |
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 |
Holor.cprankMax_1 | Mathlib.Data.Holor | ∀ {α : Type} {ds : List ℕ} [inst : Mul α] [inst_1 : AddMonoid α] {x : Holor α ds}, x.CPRankMax1 → Holor.CPRankMax 1 x |
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 |
_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 |
CategoryTheory.IsFiltered.isConnected | Mathlib.CategoryTheory.Filtered.Connected | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C], CategoryTheory.IsConnected C |
isClopen_iInter | Mathlib.Topology.AlexandrovDiscrete | ∀ {ι : Sort u_1} {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α] {f : ι → Set α},
(∀ (i : ι), IsClopen (f i)) → IsClopen (⋂ i, f i) |
_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 |
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 |
BitVec.mul_succ | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x * (y + 1#w) = x * y + x |
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, ⋯⟩ |
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) |
_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 |
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) |
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 |
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 |
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 |
RingCon.mk'._proof_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (c : RingCon R), ↑1 = ↑1 |
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) |
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 = ⊤ |
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' |
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 |
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 |
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) |
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 |
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 |
IsTop.not_isBot | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : PartialOrder α] {a : α} [Nontrivial α], IsTop a → ¬IsBot a |
bddOrd_dual_comp_forget_to_bipointed | Mathlib.Order.Category.BddOrd | BddOrd.dual.comp (CategoryTheory.forget₂ BddOrd Bipointed) =
(CategoryTheory.forget₂ BddOrd Bipointed).comp Bipointed.swap |
_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) |
_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 |
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) |
_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 |
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₂ θ) |
Lean.Data.AC.EvalInformation.evalOp | Init.Data.AC | {α : Sort u} → {β : Sort v} → [self : Lean.Data.AC.EvalInformation α β] → α → β → β → β |
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) |
ByteArray.findFinIdx?.loop | Init.Data.ByteArray.Basic | (a : ByteArray) → (UInt8 → Bool) → ℕ → Option (Fin a.size) |
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 |
_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) |
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 |
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 φ |
_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 |
Mathlib.Tactic.Push.pullStep | Mathlib.Tactic.Push | Mathlib.Tactic.Push.Head → Lean.Meta.Simp.Simproc |
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 |
_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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.