name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
BoxIntegral.Prepartition.recOn | Mathlib.Analysis.BoxIntegral.Partition.Basic | {ι : Type u_1} →
{I : BoxIntegral.Box ι} →
{motive : BoxIntegral.Prepartition I → Sort u} →
(t : BoxIntegral.Prepartition I) →
((boxes : Finset (BoxIntegral.Box ι)) →
(le_of_mem' : ∀ J ∈ boxes, J ≤ I) →
(pairwiseDisjoint : (↑boxes).Pairwise (Function.onFun Disjoint BoxIntegral.Box.toSet)) →
motive { boxes := boxes, le_of_mem' := le_of_mem', pairwiseDisjoint := pairwiseDisjoint }) →
motive t |
_private.Mathlib.Analysis.Convex.Segment.0.segment_symm.match_1_1 | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_2) {E : Type u_1} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] (x y x_1 : E) (motive : x_1 ∈ segment 𝕜 x y → Prop) (x_2 : x_1 ∈ segment 𝕜 x y),
(∀ (a b : 𝕜) (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a + b = 1) (H : a • x + b • y = x_1), motive ⋯) → motive x_2 |
NumberField.Units.instNeZeroNatTorsionOrder | Mathlib.NumberTheory.NumberField.Units.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K], NeZero (NumberField.Units.torsionOrder K) |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Skeleton.0.SSet.mem_skeleton_obj_iff_of_nonDegenerate._simp_1_4 | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.Cache.IsExtensionBy_trans_left | Std.Sat.AIG.CNF | ∀ {aig : Std.Sat.AIG ℕ} {cnf1 cnf2 cnf3 : Std.Sat.CNF ℕ} {new1 : ℕ} {hnew1 : new1 < aig.decls.size} {new2 : ℕ}
{hnew2 : new2 < aig.decls.size} (cache1 : Std.Sat.AIG.toCNF.Cache✝ aig cnf1)
(cache2 : Std.Sat.AIG.toCNF.Cache✝¹ aig cnf2) (cache3 : Std.Sat.AIG.toCNF.Cache✝² aig cnf3),
Std.Sat.AIG.toCNF.Cache.IsExtensionBy✝ cache1 cache2 new1 hnew1 →
Std.Sat.AIG.toCNF.Cache.IsExtensionBy✝¹ cache2 cache3 new2 hnew2 →
Std.Sat.AIG.toCNF.Cache.IsExtensionBy✝² cache1 cache3 new1 hnew1 |
CategoryTheory.PreOneHypercover.equivalenceMulticospanOfIso_inverse | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreOneHypercover S} (f : E ≅ F),
(CategoryTheory.PreOneHypercover.equivalenceMulticospanOfIso f).inverse =
CategoryTheory.PreOneHypercover.Hom.mapMulticospan f.inv |
OrderMonoidIso.toOrderIso_eq_coe | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Mul α] [inst_3 : Mul β]
(f : α ≃*o β), f.toOrderIso = ↑f |
Function.support_inv | Mathlib.Algebra.GroupWithZero.Indicator | ∀ {ι : Type u_1} {G₀ : Type u_3} [inst : GroupWithZero G₀] (f : ι → G₀),
(Function.support fun a => (f a)⁻¹) = Function.support f |
RingCat.fullyFaithfulForget₂ToSemiRingCat | Mathlib.Algebra.Category.Ring.Basic | (CategoryTheory.forget₂ RingCat SemiRingCat).FullyFaithful |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.pseudoMetricAux._simp_3 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {ι : Type u_1} {N : Type u_5} [inst : AddCommMonoid N] [inst_1 : Preorder N] {f : ι → N} {s : Finset ι}
[AddLeftMono N], (∀ i ∈ s, 0 ≤ f i) → (0 ≤ ∑ i ∈ s, f i) = True |
LinearPMap.mem_graph_snd_inj' | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] (f : E →ₗ.[R] F) {x y : E × F},
x ∈ f.graph → y ∈ f.graph → x.1 = y.1 → x.2 = y.2 |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Clz.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastClz.go_denote_eq._proof_1_8 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Clz | ∀ {w : ℕ} (idx idx curr : ℕ), curr + 1 < 2 ^ (curr + 1) → 2 ^ (curr + 1) < 2 ^ w → ¬curr + 1 < 2 ^ w → False |
Int.testBit_land | Mathlib.Data.Int.Bitwise | ∀ (m n : ℤ) (k : ℕ), (m.land n).testBit k = (m.testBit k && n.testBit k) |
_private.Mathlib.CategoryTheory.Monoidal.Action.End.0.CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionOfMonoidalFunctorToEndofunctorMop._simp_12 | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᴹᵒᵖ} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp f.unmop g.unmop = (CategoryTheory.CategoryStruct.comp f g).unmop |
Lean.Compiler.LCNF.ExtractClosed.State.rec | Lean.Compiler.LCNF.ExtractClosed | {motive : Lean.Compiler.LCNF.ExtractClosed.State → Sort u} →
((decls : Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) →
(fvarDecisionCache : Std.HashMap Lean.FVarId Bool) →
motive { decls := decls, fvarDecisionCache := fvarDecisionCache }) →
(t : Lean.Compiler.LCNF.ExtractClosed.State) → motive t |
MeasureTheory.JordanDecomposition.smul_posPart | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α] (j : MeasureTheory.JordanDecomposition α) (r : NNReal),
(r • j).posPart = r • j.posPart |
_private.Init.Data.Nat.ToString.0.Nat.toDigitsCore_toDigitsCore | Init.Data.Nat.ToString | ∀ {b n d fuel nf df : ℕ} {cs : List Char},
1 < b →
0 < n →
d < b →
b * n + d < fuel →
n < nf → d < df → b.toDigitsCore nf n (b.toDigitsCore df d cs) = b.toDigitsCore fuel (b * n + d) cs |
List.dropSlice.match_1 | Batteries.Data.List.Basic | {α : Type u_1} →
(motive : ℕ → ℕ → List α → Sort u_2) →
(x x_1 : ℕ) →
(x_2 : List α) →
((x x_3 : ℕ) → motive x x_3 []) →
((m : ℕ) → (xs : List α) → motive 0 m xs) →
((n m : ℕ) → (x : α) → (xs : List α) → motive n.succ m (x :: xs)) → motive x x_1 x_2 |
Option.instMax | Init.Data.Option.Basic | {α : Type u_1} → [Max α] → Max (Option α) |
QuadraticMap.restrict._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_2} {M : Type u_1} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (Q : QuadraticMap R M N) (V : Submodule R M) (a : R) (v : ↥V),
Q.toFun (a • ↑v) = (a * a) • Q.toFun ↑v |
Std.HashMap.Raw.getKey?_union_of_not_mem_right | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₂ → (m₁ ∪ m₂).getKey? k = m₁.getKey? k |
CommRingCat.equalizer_ι_isLocalHom' | Mathlib.Algebra.Category.Ring.Constructions | ∀ (F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPairᵒᵖ CommRingCat),
IsLocalHom
(CommRingCat.Hom.hom (CategoryTheory.Limits.limit.π F (Opposite.op CategoryTheory.Limits.WalkingParallelPair.one))) |
Homotopy.mkInductiveAux₁._proof_2 | Mathlib.Algebra.Homology.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{P Q : ChainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 0 ⟶ Q.X 1) (one : P.X 1 ⟶ Q.X 2)
(comm_one :
e.f 1 = CategoryTheory.CategoryStruct.comp (P.d 1 0) zero + CategoryTheory.CategoryStruct.comp one (Q.d 2 1))
(succ :
(n : ℕ) →
(p :
(f : P.X n ⟶ Q.X (n + 1)) ×'
(f' : P.X (n + 1) ⟶ Q.X (n + 2)) ×'
e.f (n + 1) =
CategoryTheory.CategoryStruct.comp (P.d (n + 1) n) f +
CategoryTheory.CategoryStruct.comp f' (Q.d (n + 2) (n + 1))) →
(f'' : P.X (n + 2) ⟶ Q.X (n + 3)) ×'
e.f (n + 2) =
CategoryTheory.CategoryStruct.comp (P.d (n + 2) (n + 1)) p.snd.fst +
CategoryTheory.CategoryStruct.comp f'' (Q.d (n + 3) (n + 2))),
e.f (0 + 2) =
CategoryTheory.CategoryStruct.comp (P.d (0 + 2) (0 + 1)) ⟨zero, ⟨one, comm_one⟩⟩.snd.fst +
CategoryTheory.CategoryStruct.comp (succ 0 ⟨zero, ⟨one, comm_one⟩⟩).fst (Q.d (0 + 3) (0 + 2)) |
neg_strictConvexOn_iff | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : SMul 𝕜 E] [inst_7 : Module 𝕜 β]
{s : Set E} {f : E → β}, StrictConvexOn 𝕜 s (-f) ↔ StrictConcaveOn 𝕜 s f |
_private.Mathlib.Data.EReal.Basic.0.EReal.coe_toReal_le._simp_1_2 | Mathlib.Data.EReal.Basic | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True |
MeasureTheory.MemLp.locallyIntegrable | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f : X → ε} {μ : MeasureTheory.Measure X} [MeasureTheory.IsLocallyFiniteMeasure μ]
{p : ENNReal}, MeasureTheory.MemLp f p μ → 1 ≤ p → MeasureTheory.LocallyIntegrable f μ |
_private.Lean.Elab.DocString.Builtin.Keywords.0.Lean.Doc.parserDescrHasAtom | Lean.Elab.DocString.Builtin.Keywords | String → Lean.ParserDescr → Lean.Elab.TermElabM (Option Lean.ParserDescr) |
Std.ExtDHashMap.get_map | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} {γ : α → Type w}
[inst : LawfulBEq α] {f : (a : α) → β a → γ a} {k : α} {h' : k ∈ Std.ExtDHashMap.map f m},
(Std.ExtDHashMap.map f m).get k h' = f k (m.get k ⋯) |
_private.Mathlib.Data.List.Sort.0.List.«_aux_Mathlib_Data_List_Sort___macroRules__private_Mathlib_Data_List_Sort_0_List_term_≼__1_1» | Mathlib.Data.List.Sort | Lean.Macro |
Std.Tactic.BVDecide.Frontend.Normalize.BitVec.add_right_eq_self | Std.Tactic.BVDecide.Normalize.Equal | ∀ {w : ℕ} (a b : BitVec w), (a + b == a) = (b == 0#w) |
Function.HasUncurry.noConfusionType | Mathlib.Logic.Function.Basic | Sort u →
{α : Type u_5} →
{β : Type u_6} →
{γ : Type u_7} →
Function.HasUncurry α β γ →
{α' : Type u_5} → {β' : Type u_6} → {γ' : Type u_7} → Function.HasUncurry α' β' γ' → Sort u |
Int.add_neg_mul_fmod_self_left | Init.Data.Int.DivMod.Lemmas | ∀ (a b c : ℤ), (a + -(b * c)).fmod b = a.fmod b |
Lean.IR.Arg.var.elim | Lean.Compiler.IR.Basic | {motive : Lean.IR.Arg → Sort u} →
(t : Lean.IR.Arg) → t.ctorIdx = 0 → ((id : Lean.IR.VarId) → motive (Lean.IR.Arg.var id)) → motive t |
_private.Mathlib.Algebra.Category.ModuleCat.Biproducts.0.lequivProdOfRightSplitExact'._proof_6 | Mathlib.Algebra.Category.ModuleCat.Biproducts | ∀ {R : Type u_2} {A M B : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup A] [inst_2 : Module R A]
[inst_3 : AddCommGroup B] [inst_4 : Module R B] [inst_5 : AddCommGroup M] [inst_6 : Module R M] {j : A →ₗ[R] M}
{g : M →ₗ[R] B} (exac : j.range = g.ker),
(CategoryTheory.ShortComplex.moduleCatMkOfKerLERange (ModuleCat.ofHom j) (ModuleCat.ofHom g) ⋯).Exact |
ENNReal.inv_mul_ne_top | Mathlib.Data.ENNReal.Inv | ∀ (a : ENNReal), a⁻¹ * a ≠ ⊤ |
_private.Mathlib.NumberTheory.Rayleigh.0.Beatty.no_collision._simp_1_7 | Mathlib.NumberTheory.Rayleigh | ∀ {R : Type v} [inst : Mul R] [inst_1 : Add R] [RightDistribClass R] (a b c : R), a * c + b * c = (a + b) * c |
UniformOnFun.instPseudoMetricSpaceOfBoundedSpace._proof_1 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : Finite ↑𝔖] [inst_1 : PseudoMetricSpace β] [BoundedSpace β]
(f g : UniformOnFun α β 𝔖),
edist f g = ENNReal.ofReal ((fun f g => ⨆ x, dist ((UniformOnFun.toFun 𝔖) f ↑x) ((UniformOnFun.toFun 𝔖) g ↑x)) f g) |
Subring.instCovariantClassHSMulLe | Mathlib.Algebra.Ring.Subring.Pointwise | ∀ {M : Type u_1} {R : Type u_2} [inst : Monoid M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R],
CovariantClass M (Subring R) HSMul.hSMul LE.le |
TopCat.Presheaf.SheafConditionPairwiseIntersections.isLimitMapConeOfIsLimitSheafConditionFork._proof_2 | Mathlib.Topology.Sheaves.SheafCondition.EqualizerProducts | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasProducts C]
{X : TopCat} (F : TopCat.Presheaf C X) {ι : Type u_1} (U : ι → TopologicalSpace.Opens ↑X)
(j : (CategoryTheory.Pairwise ι)ᵒᵖ),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.mapCone F (CategoryTheory.Pairwise.cocone U).op).pt)
(((TopCat.Presheaf.SheafConditionPairwiseIntersections.coneEquiv F U).symm.functor.obj
(TopCat.Presheaf.SheafConditionEqualizerProducts.fork F U)).π.app
j) =
(CategoryTheory.Functor.mapCone F (CategoryTheory.Pairwise.cocone U).op).π.app j |
Lean.Meta.Sym.AlphaShareCommon.State | Lean.Meta.Sym.AlphaShareCommon | Type |
MeasureTheory.IsLocallyFiniteMeasure.casesOn | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | {α : Type u_1} →
{m0 : MeasurableSpace α} →
[inst : TopologicalSpace α] →
{μ : MeasureTheory.Measure α} →
{motive : MeasureTheory.IsLocallyFiniteMeasure μ → Sort u} →
(t : MeasureTheory.IsLocallyFiniteMeasure μ) →
((finiteAtNhds : ∀ (x : α), μ.FiniteAtFilter (nhds x)) → motive ⋯) → motive t |
lift_rank_add_lift_rank_le_rank_prod | Mathlib.LinearAlgebra.Dimension.Constructions | ∀ (R : Type u) (M : Type v) (M' : Type v') [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M']
[inst_3 : Module R M] [inst_4 : Module R M'] [Nontrivial R],
Cardinal.lift.{v', v} (Module.rank R M) + Cardinal.lift.{v, v'} (Module.rank R M') ≤ Module.rank R (M × M') |
CategoryTheory.Limits.coprod.map_desc_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S T U V W : C}
[inst_1 : CategoryTheory.Limits.HasBinaryCoproduct U W] [inst_2 : CategoryTheory.Limits.HasBinaryCoproduct T V]
(f : U ⟶ S) (g : W ⟶ S) (h : T ⟶ U) (k : V ⟶ W) {Z : C} (h_1 : S ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coprod.map h k)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coprod.desc f g) h_1) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.coprod.desc (CategoryTheory.CategoryStruct.comp h f)
(CategoryTheory.CategoryStruct.comp k g))
h_1 |
_private.Lean.Elab.PreDefinition.WF.GuessLex.0.Lean.Elab.WF.GuessLex.collectHeaders.match_1 | Lean.Elab.PreDefinition.WF.GuessLex | {α : Type} →
(motive : α × ℕ × String → Sort u_1) →
(__discr : α × ℕ × String) → ((x : α) → (fst : ℕ) → (footer : String) → motive (x, fst, footer)) → motive __discr |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.OfKernel.instRKHS._proof_2 | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {X : Type u_2} {V : Type u_3} [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : CompleteSpace V] {K : Matrix X X (V →L[𝕜] V)} [inst_4 : Fact K.PosSemidef],
ContinuousConstSMul 𝕜 (UniformSpace.Completion (RKHS.H₀ K)) |
Std.Internal.List.getValue?_filter_containsKey_of_containsKey_eq_false_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((_ : α) × β)} {k : α},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₂ = false →
Std.Internal.List.getValue? k (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁) = none |
Option.elim | Init.Data.Option.Basic | {α : Type u_1} → {β : Sort u_2} → Option α → β → (α → β) → β |
CategoryTheory.Functor.CoreMonoidal.μIso_hom_natural_left._autoParam | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax |
SSet.Augmented.stdSimplex._proof_6 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ (X : SimplexCategory),
{ left := SSet.stdSimplex.map (CategoryTheory.CategoryStruct.id X),
right :=
CategoryTheory.Limits.terminal.from
{ left := SSet.stdSimplex.obj X, right := ⊤_ Type u_1,
hom :=
{
app := fun x =>
CategoryTheory.Limits.terminal.from
(((CategoryTheory.Functor.id (CategoryTheory.SimplicialObject (Type u_1))).obj
(SSet.stdSimplex.obj X)).obj
x),
naturality := ⋯ } }.right,
w := ⋯ } =
CategoryTheory.CategoryStruct.id
{ left := SSet.stdSimplex.obj X, right := ⊤_ Type u_1,
hom :=
{
app := fun x =>
CategoryTheory.Limits.terminal.from
(((CategoryTheory.Functor.id (CategoryTheory.SimplicialObject (Type u_1))).obj
(SSet.stdSimplex.obj X)).obj
x),
naturality := ⋯ } } |
MeasureTheory.«term__[_|_]» | Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic | Lean.TrailingParserDescr |
Option.not_lt_pfilter | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : LT α],
(∀ (x : α), ¬x < x) → ∀ {o : Option α} {p : (a : α) → o = some a → Bool}, ¬o < o.pfilter p |
_private.Mathlib.Data.Matrix.Cartan.0.CartanMatrix.D_off_diag_nonpos._proof_1_5 | Mathlib.Data.Matrix.Cartan | ∀ (n : ℕ) (i : Fin n), ¬-1 ≤ 0 → False |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.toParserDescr.match_1 | Lean.Elab.Syntax | (motive : (Lean.Term × ℕ) × Option ℕ → Sort u_1) →
(__discr : (Lean.Term × ℕ) × Option ℕ) →
((newStx : Lean.Term) → (snd : ℕ) → (lhsPrec? : Option ℕ) → motive ((newStx, snd), lhsPrec?)) → motive __discr |
Language.mem_one._simp_1 | Mathlib.Computability.Language | ∀ {α : Type u_1} (x : List α), (x ∈ 1) = (x = []) |
LeftInvariantDerivation.instCoeDerivationContMDiffMapModelWithCornersSelfSomeENatTop._proof_2 | Mathlib.Geometry.Manifold.Algebra.LeftInvariantDerivation | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], ContMDiffAdd (modelWithCornersSelf 𝕜 𝕜) (↑⊤) 𝕜 |
Std.DTreeMap.Internal.Impl.contains | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : α → Type v} → [Ord α] → α → Std.DTreeMap.Internal.Impl α β → Bool |
SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one_assoc | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | ∀ {Z : CategoryTheory.ObjectProperty.FullSubcategory fun a => a.len ≤ 2}
(h : { obj := SimplexCategory.mk 1, property := SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_1 } ⟶ Z),
CategoryTheory.CategoryStruct.comp
(SimplexCategory.Truncated.δ₂ 0 SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_1
SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_2)
(CategoryTheory.CategoryStruct.comp
(SimplexCategory.Truncated.σ₂ 1 SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_2
SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_1)
h) =
CategoryTheory.CategoryStruct.comp
(SimplexCategory.Truncated.σ₂ 0 SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_3
SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_4)
(CategoryTheory.CategoryStruct.comp
(SimplexCategory.Truncated.δ₂ 0 SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_4
SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_3)
h) |
Lean.Order.SeqLeft.monotone_seqLeft | Init.Internal.Order.Lemmas | ∀ {m : Type u → Type v} [inst : Monad m] [inst_1 : (α : Type u) → Lean.Order.PartialOrder (m α)] [Lean.Order.MonoBind m]
{α β : Type u} {γ : Type w} [inst_3 : Lean.Order.PartialOrder γ] [LawfulMonad m] (f : γ → m α) (g : γ → m β),
Lean.Order.monotone g → Lean.Order.monotone f → Lean.Order.monotone fun x => g x <* f x |
AddSemigroupAction | Mathlib.Algebra.Group.Action.Defs | (G : Type u_9) → Type u_10 → [AddSemigroup G] → Type (max u_10 u_9) |
PrimitiveSpectrum.gc | Mathlib.Topology.Order.HullKernel | ∀ {α : Type u_1} [inst : CompleteLattice α] {T : Set α},
GaloisConnection (fun S => OrderDual.toDual (PrimitiveSpectrum.kernel S)) fun a =>
PrimitiveSpectrum.hull T (OrderDual.ofDual a) |
TopCat.instCommRingHomObjTopCommRingCatForget₂SubtypeRingHomαContinuousCoeContinuousMapCarrier._proof_11 | Mathlib.Topology.Sheaves.CommRingCat | ∀ (X : TopCat) (R : TopCommRingCat) (x : ℕ),
CategoryTheory.ConcreteCategory.hom ↑x = CategoryTheory.ConcreteCategory.hom ↑x |
SeparationQuotient.instNonUnitalnonAssocSemiring | Mathlib.Topology.Algebra.SeparationQuotient.Basic | {R : Type u_1} →
[inst : TopologicalSpace R] →
[inst_1 : NonUnitalNonAssocSemiring R] →
[IsTopologicalSemiring R] → NonUnitalNonAssocSemiring (SeparationQuotient R) |
ONote.mul.eq_def | Mathlib.SetTheory.Ordinal.Notation | ∀ (x x_1 : ONote),
x.mul x_1 =
match x, x_1 with
| ONote.zero, x => 0
| x, ONote.zero => 0
| o₁@h:(e₁.oadd n₁ a₁), e₂.oadd n₂ a₂ => if e₂ = 0 then e₁.oadd (n₁ * n₂) a₁ else (e₁ + e₂).oadd n₂ (o₁.mul a₂) |
AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations.match_3 | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {N : Type u_1} [inst : AddCommMonoid N] {P : Type u_2} [inst_1 : AddCommMonoid P] (k : N ≃+ P) (v : P)
(motive : (∃ a, k a = v) → Prop) (x : ∃ a, k a = v), (∀ (z : N) (hz : k z = v), motive ⋯) → motive x |
AddSubgroup.closure_le_centralizer_centralizer | Mathlib.GroupTheory.Subgroup.Centralizer | ∀ {G : Type u_1} [inst : AddGroup G] (s : Set G),
AddSubgroup.closure s ≤ AddSubgroup.centralizer ↑(AddSubgroup.centralizer s) |
Batteries.AssocList.mapKey.eq_2 | Batteries.Data.AssocList | ∀ {α : Type u_1} {δ : Type u_2} {β : Type u_3} (f : α → δ) (a : α) (b : β) (es : Batteries.AssocList α β),
Batteries.AssocList.mapKey f (Batteries.AssocList.cons a b es) =
Batteries.AssocList.cons (f a) b (Batteries.AssocList.mapKey f es) |
Aesop.AddRapp.mk.injEq | Aesop.Tree.AddRapp | ∀ (toRuleApplication : Aesop.RuleApplication) (parent : Aesop.GoalRef) (appliedRule : Aesop.RegularRule)
(successProbability : Aesop.Percent) (toRuleApplication_1 : Aesop.RuleApplication) (parent_1 : Aesop.GoalRef)
(appliedRule_1 : Aesop.RegularRule) (successProbability_1 : Aesop.Percent),
({ toRuleApplication := toRuleApplication, parent := parent, appliedRule := appliedRule,
successProbability := successProbability } =
{ toRuleApplication := toRuleApplication_1, parent := parent_1, appliedRule := appliedRule_1,
successProbability := successProbability_1 }) =
(toRuleApplication = toRuleApplication_1 ∧
parent = parent_1 ∧ appliedRule = appliedRule_1 ∧ successProbability = successProbability_1) |
Lean.Meta.abstractProof | Lean.Meta.AbstractNestedProofs | {m : Type → Type} →
[inst : Monad m] →
[MonadLiftT Lean.MetaM m] →
[Lean.MonadEnv m] →
[Lean.MonadOptions m] →
[MonadFinally m] → Lean.Expr → optParam Bool true → optParam (Lean.Expr → m Lean.Expr) pure → m Lean.Expr |
Finset.consPiProd_fst | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α} (f : α → Type u_3) (has : a ∉ s) (x : (i : α) → i ∈ Finset.cons a s has → f i),
(Finset.consPiProd f has x).1 = x a ⋯ |
normGroupNorm | Mathlib.Analysis.Normed.Group.Basic | (E : Type u_5) → [inst : NormedGroup E] → GroupNorm E |
Submodule.injective_tensorToSpan | Mathlib.LinearAlgebra.Span.TensorProduct | ∀ {R : Type u_1} (A : Type u_2) {M : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M] [inst_6 : IsScalarTower R A M]
(p : Submodule R M) [Algebra.IsEpi R A] [Module.Flat R A], Function.Injective ⇑(Submodule.tensorToSpan A p) |
Subspace.dualLift_injective | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {W : Subspace K V},
Function.Injective ⇑W.dualLift |
Finmap.instDecidableMem | Mathlib.Data.Finmap | {α : Type u} → {β : α → Type v} → [DecidableEq α] → (a : α) → (s : Finmap β) → Decidable (a ∈ s) |
Aesop.Safety.ctorIdx | Aesop.Rule | Aesop.Safety → ℕ |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.merge? | Lean.Elab.Tactic.Try | Lean.TSyntax `tactic → Lean.TSyntax `tactic → Option (Lean.TSyntax `tactic) |
PrimeMultiset.coeNat | Mathlib.Data.PNat.Factors | Coe PrimeMultiset (Multiset ℕ) |
Module.End.invtSubmodule.instBoundedOrderSubtypeSubmoduleMemSublattice | Mathlib.Algebra.Module.Submodule.Invariant | {R : Type u_1} →
{M : Type u_2} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → (f : Module.End R M) → BoundedOrder ↥f.invtSubmodule |
_private.Lean.Meta.FunInfo.0.Lean.Meta.getFunInfoAux.match_4 | Lean.Meta.FunInfo | (motive : MProd Lean.FVarIdSet (Array Lean.Meta.ParamInfo) → Sort u_1) →
(r : MProd Lean.FVarIdSet (Array Lean.Meta.ParamInfo)) →
((higherOrderOutParams : Lean.FVarIdSet) →
(paramInfo : Array Lean.Meta.ParamInfo) → motive ⟨higherOrderOutParams, paramInfo⟩) →
motive r |
Polynomial.evalEval_surjective | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : Semiring R] (x y : R), Function.Surjective (Polynomial.evalEval x y) |
Nat.shiftRight_succ_inside | Init.Data.Nat.Lemmas | ∀ (m n : ℕ), m >>> (n + 1) = (m / 2) >>> n |
Std.DTreeMap.getKeyD_maxKeyD | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp],
t.isEmpty = false → ∀ {fallback fallback' : α}, t.getKeyD (t.maxKeyD fallback) fallback' = t.maxKeyD fallback |
_private.Mathlib.Computability.DFA.0.DFA.accepts_reindex._simp_1_1 | Mathlib.Computability.DFA | ∀ {α : Type u} {σ : Type v} (M : DFA α σ) {x : List α}, (x ∈ M.accepts) = (M.eval x ∈ M.accept) |
DirectSum.id._proof_5 | Mathlib.Algebra.DirectSum.Basic | ∀ (M : Type u_2) (ι : Type u_1) [inst : AddCommMonoid M] [inst_1 : Unique ι] (x : DirectSum ι fun x => M),
(DirectSum.of (fun x => M) default) ((DirectSum.toAddMonoid fun x => AddMonoidHom.id M) x) = x |
Valuation.IsRankOneDiscrete.generator_zpowers_eq_valueGroup | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {A : Type u_2} [inst_1 : Ring A] (v : Valuation A Γ)
[inst_2 : v.IsRankOneDiscrete],
Subgroup.zpowers (Valuation.IsRankOneDiscrete.generator v) = MonoidWithZeroHom.valueGroup v |
CategoryTheory.AbelianOfAdjunction.hasKernels | Mathlib.CategoryTheory.Abelian.Transfer | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D)
(G : CategoryTheory.Functor D C) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.PreservesFiniteLimits G]
(i : F.comp G ≅ CategoryTheory.Functor.id C), CategoryTheory.Limits.HasKernels C |
equicontinuous_iInf_rng | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {κ : Type u_2} {X : Type u_3} {α' : Type u_7} [tX : TopologicalSpace X] {u : κ → UniformSpace α'}
{F : ι → X → α'}, Equicontinuous F ↔ ∀ (k : κ), Equicontinuous F |
Lean.ModuleIdx.toNat | Lean.Environment | Lean.ModuleIdx → ℕ |
_private.Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet.0.«term_~ᵤ_» | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | Lean.TrailingParserDescr |
CategoryTheory.Lax.OplaxTrans.Modification.mk.inj | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} {app : (a : B) → η.app a ⟶ θ.app a}
{naturality :
autoParam
(∀ {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (F.map f) (app b)) (θ.naturality f) =
CategoryTheory.CategoryStruct.comp (η.naturality f)
(CategoryTheory.Bicategory.whiskerRight (app a) (G.map f)))
CategoryTheory.Lax.OplaxTrans.Modification.naturality._autoParam}
{app_1 : (a : B) → η.app a ⟶ θ.app a}
{naturality_1 :
autoParam
(∀ {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (F.map f) (app_1 b))
(θ.naturality f) =
CategoryTheory.CategoryStruct.comp (η.naturality f)
(CategoryTheory.Bicategory.whiskerRight (app_1 a) (G.map f)))
CategoryTheory.Lax.OplaxTrans.Modification.naturality._autoParam},
{ app := app, naturality := naturality } = { app := app_1, naturality := naturality_1 } → app = app_1 |
NonUnitalSubring.mem_inf._simp_1 | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] {p p' : NonUnitalSubring R} {x : R}, (x ∈ p ⊓ p') = (x ∈ p ∧ x ∈ p') |
Std.ExtDHashMap.Const.getKey?_alter_self | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β},
(Std.ExtDHashMap.Const.alter m k f).getKey? k =
if (f (Std.ExtDHashMap.Const.get? m k)).isSome = true then some k else none |
Vector.findSome?_singleton | Init.Data.Vector.Find | ∀ {α : Type u_1} {β : Type u_2} {a : α} {f : α → Option β}, Vector.findSome? f #v[a] = f a |
conditionallyCompleteLatticeOfsSup._proof_3 | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ (α : Type u_1) [H1 : PartialOrder α] [H2 : SupSet α],
(∀ (a b : α), BddAbove {a, b}) →
(∀ (s : Set α), BddAbove s → s.Nonempty → IsLUB s (sSup s)) → ∀ (a b x : α), a ≤ x → b ≤ x → sSup {a, b} ≤ x |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_732 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α) (h_3 : ¬[g a, g (g a)].Nodup) (w_1 : α)
(h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w [g (g a)] 1] + 1 ≤
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length →
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w [g (g a)] 1] <
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length |
Plausible.Testable.ctorIdx | Plausible.Testable | {p : Prop} → Plausible.Testable p → ℕ |
Submodule.moduleSet._proof_6 | Mathlib.Algebra.Algebra.Operations | ∀ (R : Type u_2) [inst : CommSemiring R] (A : Type u_1) [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
(P : Submodule R A), 0 • P = 0 |
_private.Lean.Shell.0.Lean.versionHeader | Lean.Shell | String |
DomAddAct.instVAddCommClassForall | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} {β : Type u_2} {α : Type u_3} {N : Type u_4} [inst : VAdd M α] [inst_1 : VAdd N β],
VAddCommClass Mᵈᵃᵃ N (α → β) |
CategoryTheory.CommSq.LiftStruct.l | Mathlib.CategoryTheory.CommSq | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{A B X Y : C} →
{f : A ⟶ X} →
{i : A ⟶ B} → {p : X ⟶ Y} → {g : B ⟶ Y} → {sq : CategoryTheory.CommSq f i p g} → sq.LiftStruct → (B ⟶ X) |
Mathlib.Tactic._aux_Mathlib_Tactic_DefEqTransformations___elabRules_Mathlib_Tactic_tacticReduce___1 | Mathlib.Tactic.DefEqTransformations | Lean.Elab.Tactic.Tactic |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.