name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
HasSubset.noConfusionType | Init.Core | Sort u_1 → {α : Type u} → HasSubset α → {α' : Type u} → HasSubset α' → Sort u_1 | false |
Std.Tactic.BVDecide.BVExpr._sizeOf_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {a : ℕ} → Std.Tactic.BVDecide.BVExpr a → ℕ | false |
Mathlib.Meta.NormNum.Result'.isNegNNRat.noConfusion | Mathlib.Tactic.NormNum.Result | {P : Sort u} →
{inst : Lean.Expr} →
{q : ℚ} →
{n d proof inst' : Lean.Expr} →
{q' : ℚ} →
{n' d' proof' : Lean.Expr} →
Mathlib.Meta.NormNum.Result'.isNegNNRat inst q n d proof =
Mathlib.Meta.NormNum.Result'.isNegNNRat inst' q' n' d' proof' →
(inst = inst' → q = q' → n = n' → d = d' → proof = proof' → P) → P | false |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.ctorElim | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_7 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof) →
ctorIdx = t.ctorIdx → Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.ctorElimType ctorIdx → motive_7 t | false |
_private.Mathlib.Tactic.NormNum.Pow.0.Mathlib.Meta.NormNum.evalPow.match_4 | Mathlib.Tactic.NormNum.Pow | {u : Lean.Level} →
{α : Q(Type u)} →
(e : Q(«$α»)) →
(motive : Option (Mathlib.Meta.NormNum.Result q(«$e»)) → Sort u_1) →
(__discr : Option (Mathlib.Meta.NormNum.Result q(«$e»))) →
((r : Mathlib.Meta.NormNum.Result q(«$e»)) → motive (some r)) →
((x : Option (Mathlib.Meta.NormNum.Result q(«$e»))) → motive x) → motive __discr | false |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.canonicalizeWithSharing | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC | Lean.Expr → Lean.Expr → Lean.Expr → Lean.Meta.SimpM Lean.Meta.Simp.Step | true |
Lean.Parser.initCacheForInput | Lean.Parser.Types | String → Lean.Parser.ParserCache | true |
ProbabilityTheory.IsFiniteKernel.isFiniteMeasure | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β}
[ProbabilityTheory.IsFiniteKernel κ] (a : α), MeasureTheory.IsFiniteMeasure (κ a) | true |
_private.Std.Sync.Broadcast.0.Std.Bounded.State.mk.injEq | Std.Sync.Broadcast | ∀ {α : Type} (producers : Std.Queue (IO.Promise Bool)) (waiters : Std.Queue (Std.Broadcast.Consumer✝ α))
(capacity : { x // 0 < x }) (size : ℕ) (buffer : Vector (IO.Ref (Std.Slot✝ α)) ↑capacity) (write read : Fin ↑capacity)
(receivers : Std.TreeMap ℕ ℕ compare) (nextId : ℕ) (closed : Bool) (pos : ℕ)
(producers_1 : Std.Queue (IO.Promise Bool)) (waiters_1 : Std.Queue (Std.Broadcast.Consumer✝¹ α))
(capacity_1 : { x // 0 < x }) (size_1 : ℕ) (buffer_1 : Vector (IO.Ref (Std.Slot✝¹ α)) ↑capacity_1)
(write_1 read_1 : Fin ↑capacity_1) (receivers_1 : Std.TreeMap ℕ ℕ compare) (nextId_1 : ℕ) (closed_1 : Bool)
(pos_1 : ℕ),
({ producers := producers, waiters := waiters, capacity := capacity, size := size, buffer := buffer, write := write,
read := read, receivers := receivers, nextId := nextId, closed := closed, pos := pos } =
{ producers := producers_1, waiters := waiters_1, capacity := capacity_1, size := size_1, buffer := buffer_1,
write := write_1, read := read_1, receivers := receivers_1, nextId := nextId_1, closed := closed_1,
pos := pos_1 }) =
(producers = producers_1 ∧
waiters = waiters_1 ∧
capacity = capacity_1 ∧
size = size_1 ∧
buffer ≍ buffer_1 ∧
write ≍ write_1 ∧
read ≍ read_1 ∧ receivers = receivers_1 ∧ nextId = nextId_1 ∧ closed = closed_1 ∧ pos = pos_1) | true |
NumberField.Units.complexEmbedding_inj._simp_1 | Mathlib.NumberTheory.NumberField.Units.Basic | ∀ {K : Type u_1} [inst : Field K] (φ : K →+* ℂ) (u v : (NumberField.RingOfIntegers K)ˣ),
((NumberField.Units.complexEmbedding φ) u = (NumberField.Units.complexEmbedding φ) v) = (u = v) | false |
CategoryTheory.Functor.leftAdjointObjIsDefined | Mathlib.CategoryTheory.Adjunction.PartialAdjoint | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor D C → CategoryTheory.ObjectProperty C | true |
Lean.Elab.Tactic.Conv.PatternMatchState.all.noConfusion | Lean.Elab.Tactic.Conv.Pattern | {P : Sort u} →
{subgoals subgoals' : Array Lean.MVarId} →
Lean.Elab.Tactic.Conv.PatternMatchState.all subgoals = Lean.Elab.Tactic.Conv.PatternMatchState.all subgoals' →
(subgoals = subgoals' → P) → P | false |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.initFn.match_1._@.Mathlib.Tactic.Positivity.Core.1480635622._hygCtx._hyg.2 | Mathlib.Tactic.Positivity.Core | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(__discr : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((fst : Array Lean.Expr) → (fst_1 : Array Lean.BinderInfo) → (e : Lean.Expr) → motive (fst, fst_1, e)) →
motive __discr | false |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.assemble₃_eq_some_iff_utf8EncodeChar_eq._proof_1_5 | Init.Data.String.Decode | ∀ {c : Char}, (String.utf8EncodeChar c).length = 3 → ¬1 < (String.utf8EncodeChar c).length → False | false |
CategoryTheory.Reflective.mk._flat_ctor | Mathlib.CategoryTheory.Adjunction.Reflective | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{R : CategoryTheory.Functor D C} →
(∀ {X Y : D}, Function.Surjective R.map) →
autoParam (∀ {X Y : D}, Function.Injective R.map) CategoryTheory.Functor.Faithful.map_injective._autoParam →
(L : CategoryTheory.Functor C D) → (L ⊣ R) → CategoryTheory.Reflective R | false |
ProbabilityTheory.indep_iSup_directed_limsup | Mathlib.Probability.Independence.ZeroOne | ∀ {Ω : Type u_2} {ι : Type u_3} {s : ι → MeasurableSpace Ω} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω}
{β : Type u_4} {p : Set ι → Prop} {f : Filter ι} {ns : β → Set ι},
(∀ (n : ι), s n ≤ m0) →
ProbabilityTheory.iIndep s μ →
(∀ (t : Set ι), p t → tᶜ ∈ f) →
Directed (fun x1 x2 => x1 ≤ x2) ns →
(∀ (a : β), p (ns a)) → ProbabilityTheory.Indep (⨆ a, ⨆ n ∈ ns a, s n) (Filter.limsup s f) μ | true |
Prod.instNonAssocRing._proof_1 | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_2} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] (a : R × S), 1 * a = a | false |
TopologicalSpace.Opens.leSupr | Mathlib.Topology.Category.TopCat.Opens | {X : TopCat} → {ι : Type u_1} → (U : ι → TopologicalSpace.Opens ↑X) → (i : ι) → U i ⟶ iSup U | true |
Std.ExtHashMap.mem_modify | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k k' : α} {f : β → β}, k' ∈ m.modify k f ↔ k' ∈ m | true |
BoxIntegral.Prepartition.iUnion_biUnion_partition | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I)
{πi : (J : BoxIntegral.Box ι) → BoxIntegral.Prepartition J},
(∀ J ∈ π, (πi J).IsPartition) → (π.biUnion πi).iUnion = π.iUnion | true |
_private.Mathlib.RingTheory.MvPolynomial.Homogeneous.0.MvPolynomial.IsHomogeneous.exists_eval_ne_zero_of_totalDegree_le_card_aux._proof_1_2 | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {n : ℕ} (i a : ℕ), n = i + a + 1 → i + (a + 1) = n | false |
Equiv.mulActionWithZero._proof_2 | Mathlib.Algebra.GroupWithZero.Action.TransferInstance | ∀ (M₀ : Type u_2) {A : Type u_1} {B : Type u_3} (e : A ≃ B) [inst : MonoidWithZero M₀] [inst_1 : Zero B]
[inst_2 : MulActionWithZero M₀ B] (b : A), 1 • b = b | false |
AddSubgroup.toSubgroup._proof_1 | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {A : Type u_1} [inst : AddGroup A] (x : AddSubgroup A),
(fun S =>
let __src := Submonoid.toAddSubmonoid S.toSubmonoid;
{ toAddSubmonoid := __src, neg_mem' := ⋯ })
((fun S =>
let __src := AddSubmonoid.toSubmonoid S.toAddSubmonoid;
{ toSubmonoid := __src, inv_mem' := ⋯ })
x) =
x | false |
MeasureTheory.Measure.addHaar_preimage_smul | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [μ.IsAddHaarMeasure] {r : ℝ},
r ≠ 0 → ∀ (s : Set E), μ ((fun x => r • x) ⁻¹' s) = ENNReal.ofReal |(r ^ Module.finrank ℝ E)⁻¹| * μ s | true |
Lean.Lsp.Command.mk.inj | Lean.Data.Lsp.Basic | ∀ {title command : String} {arguments? : Option (Array Lean.Json)} {title_1 command_1 : String}
{arguments?_1 : Option (Array Lean.Json)},
{ title := title, command := command, arguments? := arguments? } =
{ title := title_1, command := command_1, arguments? := arguments?_1 } →
title = title_1 ∧ command = command_1 ∧ arguments? = arguments?_1 | true |
Qq.SortLocalDecls.Context._sizeOf_inst | Qq.SortLocalDecls | SizeOf Qq.SortLocalDecls.Context | false |
AlgHom.isIntegrallyClosedIn | Mathlib.RingTheory.IntegralClosure.IntegrallyClosed | ∀ {R : Type u_1} [inst : CommRing R] {A : Type u_2} {B : Type u_3} [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B),
Function.Injective ⇑f → IsIntegrallyClosedIn R B → IsIntegrallyClosedIn R A | true |
Pi.addHom_apply | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {I : Type u} {f : I → Type v} {γ : Type w} [inst : (i : I) → Add (f i)] [inst_1 : Add γ] (g : (i : I) → γ →ₙ+ f i)
(x : γ) (i : I), (Pi.addHom g) x i = (g i) x | true |
_private.Mathlib.Algebra.Group.UniqueProds.Basic.0.UniqueMul.subsingleton.match_1_1 | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u_1} [inst : Mul G] {A B : Finset G} {a0 b0 : G}
(motive : { ab // ab.1 ∈ A ∧ ab.2 ∈ B ∧ ab.1 * ab.2 = a0 * b0 } → Prop)
(x : { ab // ab.1 ∈ A ∧ ab.2 ∈ B ∧ ab.1 * ab.2 = a0 * b0 }),
(∀ (_a' _b' : G) (ha' : (_a', _b').1 ∈ A) (hb' : (_a', _b').2 ∈ B) (ab' : (_a', _b').1 * (_a', _b').2 = a0 * b0),
motive ⟨(_a', _b'), ⋯⟩) →
motive x | false |
ContinuousMonoidHom.instCommGroup._proof_3 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ (A : Type u_1) (E : Type u_2) [inst : Monoid A] [inst_1 : TopologicalSpace A] [inst_2 : CommGroup E]
[inst_3 : TopologicalSpace E] [inst_4 : IsTopologicalGroup E] (n : ℕ) (a : A →ₜ* E),
zpowRec npowRec (Int.negSucc n) a = (ContinuousMonoidHom.inv E).comp (zpowRec npowRec (↑n.succ) a) | false |
Flow.reverse._proof_4 | Mathlib.Dynamics.Flow | ∀ {τ : Type u_2} [inst : AddCommGroup τ] [inst_1 : TopologicalSpace τ] [inst_2 : IsTopologicalAddGroup τ] {α : Type u_1}
[inst_3 : TopologicalSpace α] (ϕ : Flow τ α), Continuous fun x => ϕ.toFun (-x.1) x.2 | false |
preNormEDS_four | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u} [inst : CommRing R] (b c d : R), preNormEDS b c d 4 = d | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp.0.Mathlib.Meta.Positivity.evalSinh._proof_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ (α : Q(Type)) (x : Q(Zero «$α»)), «$x» =Q inferInstance | false |
SeparationQuotient.instNonUnitalCommRing._proof_13 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : NonUnitalCommRing R] [inst_2 : IsTopologicalRing R] (c : ℤ)
(x : R), SeparationQuotient.mk (c • x) = c • SeparationQuotient.mk x | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.UInt16.reduceBin.match_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.1661162788._hygCtx._hyg.3 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | (motive : Option UInt16 → Sort u_1) →
(__discr : Option UInt16) → ((m : UInt16) → motive (some m)) → ((x : Option UInt16) → motive x) → motive __discr | false |
Finset.prod_dite_eq' | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {M : Type u_3} [inst : CommMonoid M] [inst_1 : DecidableEq ι] (s : Finset ι) (a : ι)
(b : (x : ι) → x = a → M), (∏ x ∈ s, if h : x = a then b x h else 1) = if a ∈ s then b a ⋯ else 1 | true |
Batteries.RBNode.Ordered.zoom | Batteries.Data.RBMap.Alter | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {t' : Batteries.RBNode α}
{path' : Batteries.RBNode.Path α} {t : Batteries.RBNode α},
Batteries.RBNode.Ordered cmp t →
Batteries.RBNode.zoom cut t = (t', path') →
Batteries.RBNode.Ordered cmp t' ∧
Batteries.RBNode.Path.Ordered cmp path' ∧
Batteries.RBNode.All (Batteries.RBNode.Path.RootOrdered cmp path') t' ∧ Batteries.RBNode.Path.Zoomed cut path' | true |
RootPairing.IsG2.casesOn | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
{P : RootPairing ι R M N} →
{motive : P.IsG2 → Sort u} →
(t : P.IsG2) →
([toIsValuedIn : P.IsValuedIn ℤ] →
[toIsReduced : P.IsReduced] →
[toIsIrreducible : P.IsIrreducible] →
(exists_pairingIn_neg_three : ∃ i j, P.pairingIn ℤ i j = -3) → motive ⋯) →
motive t | false |
_private.Qq.ForLean.Do.0.Lean.Elab.Term.extractBind.extract? | Qq.ForLean.Do | (Lean.Expr → Lean.MetaM (Option Lean.Elab.Term.ExtractMonadResult)) →
Lean.Expr → Lean.MetaM (Option Lean.Elab.Term.ExtractMonadResult) | true |
IsCompactOpenCovered | Mathlib.Topology.Sets.CompactOpenCovered | {S : Type u_1} →
{ι : Type u_2} → {X : ι → Type u_3} → ((i : ι) → X i → S) → [(i : ι) → TopologicalSpace (X i)] → Set S → Prop | true |
CategoryTheory.PreOneHypercover.Homotopy.isLimitMultifork._simp_1 | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | false |
Module.Basis.mk_apply | Mathlib.LinearAlgebra.Basis.Basic | ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{v : ι → M} (hli : LinearIndependent R v) (hsp : ⊤ ≤ Submodule.span R (Set.range v)) (i : ι),
(Module.Basis.mk hli hsp) i = v i | true |
Lean.CollectAxioms.State.mk.injEq | Lean.Util.CollectAxioms | ∀ (visited : Lean.NameSet) (axioms : Array Lean.Name) (visited_1 : Lean.NameSet) (axioms_1 : Array Lean.Name),
({ visited := visited, axioms := axioms } = { visited := visited_1, axioms := axioms_1 }) =
(visited = visited_1 ∧ axioms = axioms_1) | true |
ContinuousLinearMap.isPositive_ofNat | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{n : ℕ} [inst_3 : n.AtLeastTwo], (OfNat.ofNat n).IsPositive | true |
String.Slice.Pattern.ForwardSliceSearcher.emptyAt.congr_simp | Init.Data.String.Pattern.String | ∀ {s : String.Slice} (pos pos_1 : s.Pos) (e_pos : pos = pos_1) (h : pos ≠ s.endPos),
String.Slice.Pattern.ForwardSliceSearcher.emptyAt pos h = String.Slice.Pattern.ForwardSliceSearcher.emptyAt pos_1 ⋯ | true |
_private.Mathlib.GroupTheory.Coset.Defs.0.QuotientAddGroup.preimage_image_mk.match_1_7 | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : AddGroup α] (N : AddSubgroup α) (s : Set α) (x : α) (motive : (∃ x_1 ∈ s, -x_1 + x ∈ N) → Prop)
(x_1 : ∃ x_1 ∈ s, -x_1 + x ∈ N), (∀ (y : α) (hs : y ∈ s) (hN : -y + x ∈ N), motive ⋯) → motive x_1 | false |
Lean.Elab.Command.checkValidCtorModifier | Lean.Elab.MutualInductive | {m : Type → Type} → [Monad m] → [Lean.MonadError m] → Lean.Elab.Modifiers → m Unit | true |
ZMod.inhabited | Mathlib.Data.ZMod.Defs | (n : ℕ) → Inhabited (ZMod n) | true |
ImplicitFunctionData.left_map_implicitFunction | Mathlib.Analysis.Calculus.Implicit | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : CompleteSpace E] {F : Type u_3} [inst_4 : NormedAddCommGroup F]
[inst_5 : NormedSpace 𝕜 F] [inst_6 : CompleteSpace F] {G : Type u_4} [inst_7 : NormedAddCommGroup G]
[inst_8 : NormedSpace 𝕜 G] [inst_9 : CompleteSpace G] (φ : ImplicitFunctionData 𝕜 E F G),
∀ᶠ (p : F × G) in nhds (φ.prodFun φ.pt), φ.leftFun (φ.implicitFunction p.1 p.2) = p.1 | true |
AlgebraicGeometry.Scheme.Hom.normalizationPullback_snd | Mathlib.AlgebraicGeometry.Normalization | ∀ {X S Y : AlgebraicGeometry.Scheme} (f : X ⟶ S) (g : Y ⟶ S) [inst : AlgebraicGeometry.QuasiCompact f]
[inst_1 : AlgebraicGeometry.QuasiSeparated f],
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.normalizationPullback f g)
(CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Hom.fromNormalization f) g) =
AlgebraicGeometry.Scheme.Hom.fromNormalization (CategoryTheory.Limits.pullback.snd f g) | true |
Lean.Parser.Term.let._regBuiltin.Lean.Parser.Term.letIdDecl.formatter_61 | Lean.Parser.Term | IO Unit | false |
CategoryTheory.IsMonHom.casesOn | Mathlib.CategoryTheory.Monoidal.Mon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M N : C} →
[inst_2 : CategoryTheory.MonObj M] →
[inst_3 : CategoryTheory.MonObj N] →
{f : M ⟶ N} →
{motive : CategoryTheory.IsMonHom f → Sort u} →
(t : CategoryTheory.IsMonHom f) →
((one_hom :
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one f = CategoryTheory.MonObj.one) →
(mul_hom :
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.mul f =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom f f)
CategoryTheory.MonObj.mul) →
motive ⋯) →
motive t | false |
inv_nonpos._simp_1 | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : LinearOrder G₀] {a : G₀} [PosMulMono G₀], (a⁻¹ ≤ 0) = (a ≤ 0) | false |
_private.Mathlib.Analysis.Normed.Group.Basic.0.Mathlib.Meta.Positivity.evalMulNorm.match_7 | Mathlib.Analysis.Normed.Group.Basic | (u_1 : Lean.Level) →
(E : Q(Type u_1)) →
(motive : Lean.LOption Q(NormedGroup «$E») → Sort u_1) →
(__discr : Lean.LOption Q(NormedGroup «$E»)) →
((normedGroup_E : Q(NormedGroup «$E»)) → motive (Lean.LOption.some normedGroup_E)) →
((x : Lean.LOption Q(NormedGroup «$E»)) → motive x) → motive __discr | false |
CategoryTheory.IsKernelPair.isIso_of_mono | Mathlib.CategoryTheory.Limits.Shapes.KernelPair | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {R X Y : C} {f : X ⟶ Y} {a b : R ⟶ X},
CategoryTheory.IsKernelPair f a b → ∀ [CategoryTheory.Mono f], CategoryTheory.IsIso a | true |
CategoryTheory.Localization.Monoidal.braidingNatIso._proof_1 | Mathlib.CategoryTheory.Localization.Monoidal.Braided | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (W : CategoryTheory.MorphismProperty C)
[inst_1 : CategoryTheory.MonoidalCategory C] [W.IsMonoidal], W.ContainsIdentities | false |
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.Padic.valuation_zpow._simp_1_3 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {α : Type u} [inst : Mul α] [inst_1 : HasDistribNeg α] (a b : α), -(a * b) = -a * b | false |
FirstOrder.Language.age.is_equiv_invariant | Mathlib.ModelTheory.Fraisse | ∀ (L : FirstOrder.Language) (M : Type w) [inst : L.Structure M] (N P : CategoryTheory.Bundled L.Structure),
Nonempty (L.Equiv ↑N ↑P) → (N ∈ L.age M ↔ P ∈ L.age M) | true |
Vector.getElem_insertIdx_of_gt._proof_6 | Init.Data.Vector.InsertIdx | ∀ {n i k : ℕ}, k ≤ n → k > i → k - 1 < n | false |
Std.Time.TimeZone.Transition._sizeOf_inst | Std.Time.Zoned.ZoneRules | SizeOf Std.Time.TimeZone.Transition | false |
_private.Mathlib.NumberTheory.LSeries.PrimesInAP.0.ArithmeticFunction.vonMangoldt.support_residueClass_prime_div._simp_1_4 | Mathlib.NumberTheory.LSeries.PrimesInAP | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] {n : ℕ}, (↑n = 0) = (n = 0) | false |
ProofWidgets.Penrose.RpcEncodablePacket._@.ProofWidgets.Component.PenroseDiagram.3621647104._hygCtx._hyg.1 | ProofWidgets.Component.PenroseDiagram | Type | false |
Function.Surjective.addActionLeft._proof_2 | Mathlib.Algebra.Group.Action.Hom | ∀ {R : Type u_3} {S : Type u_2} {M : Type u_1} [inst : AddMonoid R] [inst_1 : AddAction R M] [inst_2 : AddMonoid S]
[inst_3 : VAdd S M] (f : R →+ S), (∀ (c : R) (x : M), f c +ᵥ x = c +ᵥ x) → ∀ (b : M), 0 +ᵥ b = b | false |
Nat.nth_mem | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop} (n : ℕ), (∀ (hf : (setOf p).Finite), n < hf.toFinset.card) → p (Nat.nth p n) | true |
partialFunEquivPointed._proof_3 | Mathlib.CategoryTheory.Category.PartialFun | ∀ (X : PartialFun) (a : (partialFunToPointed.comp pointedToPartialFun).obj X), Option.isSome ↑a = true | false |
absorbent_ball_zero | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
{r : ℝ}, 0 < r → Absorbent 𝕜 (Metric.ball 0 r) | true |
CategoryTheory.Abelian.SpectralObject.opcyclesIsoH_hom | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i₀ i₁ : ι} (f : i₀ ⟶ i₁) (n₀ n₁ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObject.opcyclesIsoH_hom._auto_1),
(X.opcyclesIsoH f n₀ n₁ hn₁).hom = X.fromOpcycles f (CategoryTheory.CategoryStruct.id i₁) f ⋯ n₁ | true |
_private.Lean.Elab.Frontend.0.Lean.Elab.IO.processCommandsIncrementally.match_1 | Lean.Elab.Frontend | (motive : Option (Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot) → Sort u_1) →
(x : Option (Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot)) →
((next : Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot) → motive (some next)) →
((x : Option (Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot)) → motive x) → motive x | false |
UInt16.ofBitVec_or | Init.Data.UInt.Bitwise | ∀ (a b : BitVec 16), { toBitVec := a ||| b } = { toBitVec := a } ||| { toBitVec := b } | true |
_private.Std.Sat.CNF.Dimacs.0.Std.Sat.CNF.DimacsM.handleLit | Std.Sat.CNF.Dimacs | Std.Sat.Literal ℕ → Std.Sat.CNF.DimacsM✝ Unit | true |
FirstOrder.Language.Term.varFinset | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} → {α : Type u'} → [DecidableEq α] → L.Term α → Finset α | true |
Subalgebra.rTensorBot | Mathlib.LinearAlgebra.TensorProduct.Subalgebra | {R : Type u_1} →
{S : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Semiring S] → [inst_2 : Algebra R S] → (A : Subalgebra R S) → TensorProduct R ↥A ↥⊥ ≃ₐ[R] ↥A | true |
UInt16.or_eq_zero_iff | Init.Data.UInt.Bitwise | ∀ {a b : UInt16}, a ||| b = 0 ↔ a = 0 ∧ b = 0 | true |
Bool.ite_then_false_eq_false | Init.PropLemmas | ∀ {p : Prop} [inst : Decidable p] {x : Bool}, (if p then false else x) = false ↔ p ∨ x = false | true |
Real.HolderTriple.lt | Mathlib.Data.Real.ConjExponents | ∀ {p q r : ℝ}, p.HolderTriple q r → r < p | true |
_private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso._proof_3 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.MonoidalCategory D]
(A : CategoryTheory.Comon (CategoryTheory.Functor C D)),
CategoryTheory.CategoryStruct.comp
{
app := fun x =>
CategoryTheory.CategoryStruct.id
(((CategoryTheory.Functor.id (CategoryTheory.Comon (CategoryTheory.Functor C D))).obj A).X.obj x),
naturality := ⋯ }
CategoryTheory.ComonObj.comul =
CategoryTheory.CategoryStruct.comp CategoryTheory.ComonObj.comul
(CategoryTheory.MonoidalCategoryStruct.tensorHom
{
app := fun x =>
CategoryTheory.CategoryStruct.id
(((CategoryTheory.Functor.id (CategoryTheory.Comon (CategoryTheory.Functor C D))).obj A).X.obj x),
naturality := ⋯ }
{
app := fun x =>
CategoryTheory.CategoryStruct.id
(((CategoryTheory.Functor.id (CategoryTheory.Comon (CategoryTheory.Functor C D))).obj A).X.obj x),
naturality := ⋯ }) | false |
Lean.Compiler.LCNF.LetValue.ctorElimType | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → {motive : Lean.Compiler.LCNF.LetValue pu → Sort u} → ℕ → Sort (max 1 u) | false |
CochainComplex.ConnectData.homologyIsoPos._proof_11 | Mathlib.Algebra.Homology.Embedding.Connect | ∀ (m : ℤ), (ComplexShape.up ℤ).prev m = m - 1 | false |
Finset.affineCombinationLineMapWeights_apply_of_ne | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {k : Type u_1} [inst : Ring k] {ι : Type u_4} [inst_1 : DecidableEq ι] {i j t : ι},
t ≠ i → t ≠ j → ∀ (c : k), Finset.affineCombinationLineMapWeights i j c t = 0 | true |
IsLocallyConstant.desc | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {α : Type u_5} {β : Type u_6} (f : X → α) (g : α → β),
IsLocallyConstant (g ∘ f) → Function.Injective g → IsLocallyConstant f | true |
UInt32.toUSize_shiftLeft_of_lt | Init.Data.UInt.Bitwise | ∀ (a b : UInt32), b < 32 → (a <<< b).toUSize = a.toUSize <<< b.toUSize % 4294967296 | true |
Lean.Elab.ComputedFields.computedFieldAttr._regBuiltin.Lean.Elab.ComputedFields.computedFieldAttr.docString_1 | Lean.Elab.ComputedFields | IO Unit | false |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.restrictNonposSeq_subset | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : MeasureTheory.SignedMeasure α} {i : Set α} (n : ℕ),
MeasureTheory.SignedMeasure.restrictNonposSeq✝ s i n ⊆ i | true |
Nat.gcdB_zero_right | Mathlib.Data.Int.GCD | ∀ {s : ℕ}, s ≠ 0 → s.gcdB 0 = 0 | true |
PartialEquiv.single_apply | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (a : α) (b : β) (a_1 : α), ↑(PartialEquiv.single a b) a_1 = Function.const α b a_1 | true |
MonoidWithZeroHom.one_apply_def | Mathlib.Algebra.GroupWithZero.Hom | ∀ {M₀ : Type u_7} {N₀ : Type u_8} [inst : MulZeroOneClass M₀] [inst_1 : MulZeroOneClass N₀]
[inst_2 : DecidablePred fun x => x = 0] [inst_3 : Nontrivial M₀] [inst_4 : NoZeroDivisors M₀] (x : M₀),
1 x = if x = 0 then 0 else 1 | true |
_private.ProofWidgets.Data.Html.0.ProofWidgets.instFromJsonRpcEncodablePacket.fromJson.match_1._@.ProofWidgets.Data.Html.2463204861._hygCtx._hyg.32 | ProofWidgets.Data.Html | (motive : String → Sort u_1) →
(tag : String) →
(Unit → motive "text") →
(Unit → motive "element") → (Unit → motive "component") → ((x : String) → motive x) → motive tag | false |
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraided._proof_7 | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : CategoryTheory.CommMon C),
{
hom :=
{ hom := { app := fun x => (CategoryTheory.CategoryStruct.id X).hom.hom, naturality := ⋯ },
isMonoidal := ⋯ } } =
CategoryTheory.CategoryStruct.id
(CategoryTheory.LaxBraidedFunctor.of
(CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraidedObj X)) | false |
Std.DTreeMap.Const.getKey_alter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
[Inhabited α] {k k' : α} {f : Option β → Option β} {hc : k' ∈ Std.DTreeMap.Const.alter t k f},
(Std.DTreeMap.Const.alter t k f).getKey k' hc = if heq : cmp k k' = Ordering.eq then k else t.getKey k' ⋯ | true |
PosSMulReflectLT.recOn | Mathlib.Algebra.Order.Module.Defs | {α : Type u_1} →
{β : Type u_2} →
[inst : SMul α β] →
[inst_1 : Preorder α] →
[inst_2 : Preorder β] →
[inst_3 : Zero α] →
{motive : PosSMulReflectLT α β → Sort u} →
(t : PosSMulReflectLT α β) →
((lt_of_smul_lt_smul_left : ∀ ⦃a : α⦄, 0 ≤ a → ∀ ⦃b₁ b₂ : β⦄, a • b₁ < a • b₂ → b₁ < b₂) → motive ⋯) →
motive t | false |
Nat.toList_roc_append_toList_roc | Init.Data.Range.Polymorphic.NatLemmas | ∀ {l m n : ℕ}, l ≤ m → m ≤ n → (l<...=m).toList ++ (m<...=n).toList = (l<...=n).toList | true |
Std.DTreeMap.Internal.Impl.maxKey?_erase!_eq_iff_not_compare_eq_maxKey? | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
∀ {k : α},
(Std.DTreeMap.Internal.Impl.erase! k t).maxKey? = t.maxKey? ↔
∀ {km : α}, t.maxKey? = some km → ¬compare k km = Ordering.eq | true |
Std.TreeSet.getGT | Std.Data.TreeSet.AdditionalOperations | {α : Type u} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → (t : Std.TreeSet α cmp) → (k : α) → (∃ a ∈ t, cmp a k = Ordering.gt) → α | true |
Nat.toList_ric_eq_toList_rio_append | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n : ℕ}, (*...=n).toList = (*...n).toList ++ [n] | true |
LieAlgebra.HasCentralRadical.radical_eq_center | Mathlib.Algebra.Lie.Semisimple.Defs | ∀ {R : Type u_1} {L : Type u_2} {inst : CommRing R} {inst_1 : LieRing L} {inst_2 : LieAlgebra R L}
[self : LieAlgebra.HasCentralRadical R L], LieAlgebra.radical R L = LieAlgebra.center R L | true |
Option.filterM_none | Init.Data.Option.Monadic | ∀ {m : Type → Type u_1} {α : Type} [inst : Applicative m] (p : α → m Bool), Option.filterM p none = pure none | true |
Lean.Elab.Term.Context.isNoncomputableSection._default | Lean.Elab.Term.TermElabM | Bool | false |
Std.DTreeMap.Raw.insertMany | Std.Data.DTreeMap.Raw.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
{ρ : Type u_1} → [ForIn Id ρ ((a : α) × β a)] → Std.DTreeMap.Raw α β cmp → ρ → Std.DTreeMap.Raw α β cmp | true |
RegularExpression.rmatch.congr_simp | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} {inst : DecidableEq α} [inst_1 : DecidableEq α] (a a_1 : RegularExpression α),
a = a_1 → ∀ (a_2 a_3 : List α), a_2 = a_3 → a.rmatch a_2 = a_1.rmatch a_3 | true |
CategoryTheory.GrpObj.instIsIsoInv | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(A : C) [inst_2 : CategoryTheory.GrpObj A], CategoryTheory.IsIso CategoryTheory.GrpObj.inv | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.