tasksource/leandojo huggingface dataset:
Theorem: ProbabilityTheory.kernel.set_integral_piecewise
File: Mathlib/Probability/Kernel/Basic.lean

tactic: simp_rw [piecewise_apply]
state_before: α : Type u_3
β : Type u_2
ι : Type ?u.1474570
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : { x // x ∈ kernel α β }
s : Set α
hs : MeasurableSet s
inst✝³ : DecidablePred fun x => x ∈ s
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
a : α
g : β → E
t : Set β
⊢ (∫ (b : β) in t, g b ∂↑(piecewise hs κ η) a) = if a ∈ s then ∫ (b : β) in t, g b ∂↑κ a else ∫ (b : β) in t, g b ∂↑η a

tactic: split_ifs <;> rfl
state_before: α : Type u_3
β : Type u_2
ι : Type ?u.1474570
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : { x // x ∈ kernel α β }
s : Set α
hs : MeasurableSet s
inst✝³ : DecidablePred fun x => x ∈ s
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
a : α
g : β → E
t : Set β
⊢ (∫ (b : β) in t, g b ∂if a ∈ s then ↑κ a else ↑η a) =
    if a ∈ s then ∫ (b : β) in t, g b ∂↑κ a else ∫ (b : β) in t, g b ∂↑η a
Theorem: Concept.ext'
File: Mathlib/Order/Concept.lean

tactic: obtain ⟨⟨s₁, t₁⟩, _, h₁⟩ := c
state_before: ι : Sort ?u.6130
α : Type u_2
β : Type u_1
γ : Type ?u.6139
κ : ι → Sort ?u.6144
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
h : c.snd = d.snd
⊢ c = d

tactic: obtain ⟨⟨s₂, t₂⟩, _, h₂⟩ := d
state_before: case mk.mk
ι : Sort ?u.6130
α : Type u_2
β : Type u_1
γ : Type ?u.6139
κ : ι → Sort ?u.6144
r : α → β → Prop
s s₁✝ s₂ : Set α
t t₁✝ t₂ : Set β
d : Concept α β r
s₁ : Set α
t₁ : Set β
closure_fst✝ : intentClosure r (s₁, t₁).fst = (s₁, t₁).snd
h₁ : extentClosure r (s₁, t₁).snd = (s₁, t₁).fst
h : { toProd := (s₁, t₁), closure_fst := closure_fst✝, closure_snd := h₁ }.toProd.snd = d.snd
⊢ { toProd := (s₁, t₁), closure_fst := closure_fst✝, closure_snd := h₁ } = d

tactic: dsimp at h₁ h₂ h
state_before: case mk.mk.mk.mk
ι : Sort ?u.6130
α : Type u_2
β : Type u_1
γ : Type ?u.6139
κ : ι → Sort ?u.6144
r : α → β → Prop
s s₁✝ s₂✝ : Set α
t t₁✝ t₂✝ : Set β
s₁ : Set α
t₁ : Set β
closure_fst✝¹ : intentClosure r (s₁, t₁).fst = (s₁, t₁).snd
h₁ : extentClosure r (s₁, t₁).snd = (s₁, t₁).fst
s₂ : Set α
t₂ : Set β
closure_fst✝ : intentClosure r (s₂, t₂).fst = (s₂, t₂).snd
h₂ : extentClosure r (s₂, t₂).snd = (s₂, t₂).fst
h :
  { toProd := (s₁, t₁), closure_fst := closure_fst✝¹, closure_snd := h₁ }.toProd.snd =
    { toProd := (s₂, t₂), closure_fst := closure_fst✝, closure_snd := h₂ }.toProd.snd
⊢ { toProd := (s₁, t₁), closure_fst := closure_fst✝¹, closure_snd := h₁ } =
    { toProd := (s₂, t₂), closure_fst := closure_fst✝, closure_snd := h₂ }

tactic: substs h h₁ h₂
state_before: case mk.mk.mk.mk
ι : Sort ?u.6130
α : Type u_2
β : Type u_1
γ : Type ?u.6139
κ : ι → Sort ?u.6144
r : α → β → Prop
s s₁✝ s₂✝ : Set α
t t₁✝ t₂✝ : Set β
s₁ : Set α
t₁ : Set β
closure_fst✝¹ : intentClosure r (s₁, t₁).fst = (s₁, t₁).snd
h₁ : extentClosure r t₁ = s₁
s₂ : Set α
t₂ : Set β
closure_fst✝ : intentClosure r (s₂, t₂).fst = (s₂, t₂).snd
h₂ : extentClosure r t₂ = s₂
h : t₁ = t₂
⊢ { toProd := (s₁, t₁), closure_fst := closure_fst✝¹, closure_snd := h₁ } =
    { toProd := (s₂, t₂), closure_fst := closure_fst✝, closure_snd := h₂ }

tactic: rfl
state_before: case mk.mk.mk.mk
ι : Sort ?u.6130
α : Type u_2
β : Type u_1
γ : Type ?u.6139
κ : ι → Sort ?u.6144
r : α → β → Prop
s s₁ s₂ : Set α
t t₁✝ t₂ t₁ : Set β
closure_fst✝¹ closure_fst✝ : intentClosure r (extentClosure r t₁, t₁).fst = (extentClosure r t₁, t₁).snd
⊢ { toProd := (extentClosure r t₁, t₁), closure_fst := closure_fst✝¹,
      closure_snd := (_ : extentClosure r t₁ = extentClosure r t₁) } =
    { toProd := (extentClosure r t₁, t₁), closure_fst := closure_fst✝,
      closure_snd := (_ : extentClosure r t₁ = extentClosure r t₁) }
Theorem: dNext_eq
File: Mathlib/Algebra/Homology/Homotopy.lean

tactic: obtain rfl := c.next_eq' w
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i✝ : ι
f : (i j : ι) → X C i ⟶ X D j
i i' : ι
w : ComplexShape.Rel c i i'
⊢ ↑(dNext i) f = d C i i' ≫ f i' i

tactic: rfl
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i✝ : ι
f : (i j : ι) → X C i ⟶ X D j
i : ι
w : ComplexShape.Rel c i (ComplexShape.next c i)
⊢ ↑(dNext i) f = d C i (ComplexShape.next c i) ≫ f (ComplexShape.next c i) i
Theorem: Set.Finite.biUnion'
File: Mathlib/Data/Set/Finite.lean

tactic: cases hs
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : Set ι
hs : Set.Finite s
t : (i : ι) → i ∈ s → Set α
ht : ∀ (i : ι) (hi : i ∈ s), Set.Finite (t i hi)
⊢ Set.Finite (⋃ (i : ι) (h : i ∈ s), t i h)

tactic: rw [biUnion_eq_iUnion]
state_before: case intro
α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : Set ι
t : (i : ι) → i ∈ s → Set α
ht : ∀ (i : ι) (hi : i ∈ s), Set.Finite (t i hi)
a✝ : Fintype ↑s
⊢ Set.Finite (⋃ (i : ι) (h : i ∈ s), t i h)

tactic: apply finite_iUnion fun i : s => ht i.1 i.2
state_before: case intro
α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : Set ι
t : (i : ι) → i ∈ s → Set α
ht : ∀ (i : ι) (hi : i ∈ s), Set.Finite (t i hi)
a✝ : Fintype ↑s
⊢ Set.Finite (⋃ (x : ↑s), t ↑x (_ : ↑x ∈ s))
Theorem: Part.map_id'
File: Mathlib/Data/Part.lean

tactic: rw [show f = id from funext H]
state_before: α : Type u_1
β : Type ?u.49680
γ : Type ?u.49683
f : α → α
H : ∀ (x : α), f x = x
o : Part α
⊢ map f o = o

tactic: exact id_map o
state_before: α : Type u_1
β : Type ?u.49680
γ : Type ?u.49683
f : α → α
H : ∀ (x : α), f x = x
o : Part α
⊢ map id o = o
Theorem: MvPolynomial.ne_zero_iff
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [Ne.def, eq_zero_iff]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q p : MvPolynomial σ R
⊢ p ≠ 0 ↔ ∃ d, coeff d p ≠ 0

tactic: push_neg
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q p : MvPolynomial σ R
⊢ (¬∀ (d : σ →₀ ℕ), coeff d p = 0) ↔ ∃ d, coeff d p ≠ 0

tactic: rfl
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q p : MvPolynomial σ R
⊢ (∃ d, coeff d p ≠ 0) ↔ ∃ d, coeff d p ≠ 0
Theorem: round_one
File: Mathlib/Algebra/Order/Floor.lean

tactic: simp [round]
state_before: F : Type ?u.250745
α : Type u_1
β : Type ?u.250751
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
⊢ round 1 = 1
Theorem: Polynomial.root_right_of_root_gcd
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: cases' EuclideanDomain.gcd_dvd_right f g with p hp
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
inst✝ : CommSemiring k
ϕ : R →+* k
f g : R[X]
α : k
hα : eval₂ ϕ α (EuclideanDomain.gcd f g) = 0
⊢ eval₂ ϕ α g = 0

tactic: rw [hp, Polynomial.eval₂_mul, hα, MulZeroClass.zero_mul]
state_before: case intro
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Field R
p✝ q : R[X]
inst✝ : CommSemiring k
ϕ : R →+* k
f g : R[X]
α : k
hα : eval₂ ϕ α (EuclideanDomain.gcd f g) = 0
p : R[X]
hp : g = EuclideanDomain.gcd f g * p
⊢ eval₂ ϕ α g = 0
Theorem: ProbabilityTheory.kernel.lintegral_const
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [kernel.const_apply]
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.865618
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : { x // x ∈ kernel α β }
f : β → ℝ≥0∞
μ : MeasureTheory.Measure β
a : α
⊢ (∫⁻ (x : β), f x ∂↑(const α μ) a) = ∫⁻ (x : β), f x ∂μ
Theorem: ContDiffAt.dist
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: simp only [dist_eq_norm]
state_before: 𝕜 : Type ?u.276081
E : Type u_2
F : Type ?u.276087
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_1
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x : G
n : ℕ∞
hf : ContDiffAt ℝ n f x
hg : ContDiffAt ℝ n g x
hne : f x ≠ g x
⊢ ContDiffAt ℝ n (fun y => Dist.dist (f y) (g y)) x

tactic: exact (hf.sub hg).norm 𝕜 (sub_ne_zero.2 hne)
state_before: 𝕜 : Type ?u.276081
E : Type u_2
F : Type ?u.276087
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_1
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x : G
n : ℕ∞
hf : ContDiffAt ℝ n f x
hg : ContDiffAt ℝ n g x
hne : f x ≠ g x
⊢ ContDiffAt ℝ n (fun y => ‖f y - g y‖) x
Theorem: edist_vadd_vadd_le
File: Mathlib/Analysis/Normed/Group/AddTorsor.lean

tactic: simp only [edist_nndist]
state_before: α : Type ?u.26982
V : Type u_2
P : Type u_1
W : Type ?u.26991
Q : Type ?u.26994
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
v v' : V
p p' : P
⊢ edist (v +ᵥ p) (v' +ᵥ p') ≤ edist v v' + edist p p'

tactic: norm_cast
state_before: α : Type ?u.26982
V : Type u_2
P : Type u_1
W : Type ?u.26991
Q : Type ?u.26994
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
v v' : V
p p' : P
⊢ ↑(nndist (v +ᵥ p) (v' +ᵥ p')) ≤ ↑(nndist v v') + ↑(nndist p p')

tactic: apply dist_vadd_vadd_le
state_before: α : Type ?u.26982
V : Type u_2
P : Type u_1
W : Type ?u.26991
Q : Type ?u.26994
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
v v' : V
p p' : P
⊢ nndist (v +ᵥ p) (v' +ᵥ p') ≤ nndist v v' + nndist p p'
Theorem: Con.mapOfSurjective_eq_mapGen
File: Mathlib/GroupTheory/Congruence.lean

tactic: rw [← conGen_of_con (c.mapOfSurjective f H h hf)]
state_before: M : Type u_1
N : Type u_2
P : Type ?u.35290
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c : Con M
f : M → N
H : ∀ (x y : M), f (x * y) = f x * f y
h : mulKer f H ≤ c
hf : Surjective f
⊢ mapGen c f = mapOfSurjective c f H h hf

tactic: rfl
state_before: M : Type u_1
N : Type u_2
P : Type ?u.35290
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c : Con M
f : M → N
H : ∀ (x y : M), f (x * y) = f x * f y
h : mulKer f H ≤ c
hf : Surjective f
⊢ mapGen c f = conGen ↑(mapOfSurjective c f H h hf)
Theorem: FiniteDimensional.finrank_eq_card_finset_basis
File: Mathlib/LinearAlgebra/Finrank.lean

tactic: rw [finrank_eq_card_basis h, Fintype.card_coe]
state_before: K : Type u
V : Type v
inst✝⁵ : Ring K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : StrongRankCondition K
ι : Type w
b : Finset ι
h : Basis { x // x ∈ b } K V
⊢ finrank K V = Finset.card b
Theorem: Asymptotics.IsBigOWith.of_pow
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: gcongr
state_before: α : Type u_1
β : Type ?u.500881
E : Type ?u.500884
F : Type ?u.500887
G : Type ?u.500890
E' : Type ?u.500893
F' : Type ?u.500896
G' : Type ?u.500899
E'' : Type ?u.500902
F'' : Type ?u.500905
G'' : Type ?u.500908
R : Type u_3
R' : Type ?u.500914
𝕜 : Type u_2
𝕜' : Type ?u.500920
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α → E
g✝ : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
n : ℕ
f : α → 𝕜
g : α → R
h : IsBigOWith c l (f ^ n) (g ^ n)
hn : n ≠ 0
hc : c ≤ c' ^ n
hc' : 0 ≤ c'
x : α
hx : ‖(f ^ n) x‖ ≤ c' ^ n * ‖(g ^ n) x‖
⊢ c' ^ n * ‖g x ^ n‖ ≤ c' ^ n * ‖g x‖ ^ n

tactic: exact norm_pow_le' _ hn.bot_lt
state_before: case h
α : Type u_1
β : Type ?u.500881
E : Type ?u.500884
F : Type ?u.500887
G : Type ?u.500890
E' : Type ?u.500893
F' : Type ?u.500896
G' : Type ?u.500899
E'' : Type ?u.500902
F'' : Type ?u.500905
G'' : Type ?u.500908
R : Type u_3
R' : Type ?u.500914
𝕜 : Type u_2
𝕜' : Type ?u.500920
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α → E
g✝ : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
n : ℕ
f : α → 𝕜
g : α → R
h : IsBigOWith c l (f ^ n) (g ^ n)
hn : n ≠ 0
hc : c ≤ c' ^ n
hc' : 0 ≤ c'
x : α
hx : ‖(f ^ n) x‖ ≤ c' ^ n * ‖(g ^ n) x‖
⊢ ‖g x ^ n‖ ≤ ‖g x‖ ^ n
Theorem: multiplicity.get_multiplicity_self
File: Mathlib/RingTheory/Multiplicity.lean

tactic: simp
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : Finite a a
⊢ a ^ 1 ∣ a

tactic: rw [← mul_one a, pow_add, pow_one, mul_assoc, mul_assoc,
    mul_right_inj' (ne_zero_of_finite ha)] at hb
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : Finite a a
x✝ : a ^ (1 + 1) ∣ a
b : α
hb : a = a ^ (1 + 1) * b
⊢ False

tactic: exact
  mt isUnit_iff_dvd_one.2 (not_unit_of_finite ha) ⟨b, by simp_all⟩
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : Finite a a
x✝ : a ^ (1 + 1) ∣ a
b : α
hb : 1 = 1 * (a * 1 * b)
⊢ False

tactic: simp_all
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : Finite a a
x✝ : a ^ (1 + 1) ∣ a
b : α
hb : 1 = 1 * (a * 1 * b)
⊢ 1 = a * b
Theorem: CategoryTheory.Limits.Concrete.widePushout_exists_rep
File: Mathlib/CategoryTheory/Limits/ConcreteCategory.lean

tactic: obtain ⟨_ | j, y, rfl⟩ := Concrete.colimit_exists_rep _ x
state_before: C : Type u
inst✝⁵ : Category C
inst✝⁴ : ConcreteCategory C
J : Type v
inst✝³ : SmallCategory J
F : J ⥤ C
inst✝² : PreservesColimit F (forget C)
B : C
α : Type v
X : α → C
f : (j : α) → B ⟶ X j
inst✝¹ : HasWidePushout B X f
inst✝ : PreservesColimit (wideSpan B X f) (forget C)
x : (forget C).obj (widePushout B X f)
⊢ (∃ y, (forget C).map (head f) y = x) ∨ ∃ i y, (forget C).map (ι f i) y = x

tactic: left
state_before: case intro.none.intro
C : Type u
inst✝⁵ : Category C
inst✝⁴ : ConcreteCategory C
J : Type v
inst✝³ : SmallCategory J
F : J ⥤ C
inst✝² : PreservesColimit F (forget C)
B : C
α : Type v
X : α → C
f : (j : α) → B ⟶ X j
inst✝¹ : HasWidePushout B X f
inst✝ : PreservesColimit (wideSpan B X f) (forget C)
y : (forget C).obj ((wideSpan B X f).obj none)
⊢ (∃ y_1, (forget C).map (head f) y_1 = (forget C).map (colimit.ι (wideSpan B X f) none) y) ∨
    ∃ i y_1, (forget C).map (ι f i) y_1 = (forget C).map (colimit.ι (wideSpan B X f) none) y

tactic: use y
state_before: case intro.none.intro.h
C : Type u
inst✝⁵ : Category C
inst✝⁴ : ConcreteCategory C
J : Type v
inst✝³ : SmallCategory J
F : J ⥤ C
inst✝² : PreservesColimit F (forget C)
B : C
α : Type v
X : α → C
f : (j : α) → B ⟶ X j
inst✝¹ : HasWidePushout B X f
inst✝ : PreservesColimit (wideSpan B X f) (forget C)
y : (forget C).obj ((wideSpan B X f).obj none)
⊢ ∃ y_1, (forget C).map (head f) y_1 = (forget C).map (colimit.ι (wideSpan B X f) none) y

tactic: right
state_before: case intro.some.intro
C : Type u
inst✝⁵ : Category C
inst✝⁴ : ConcreteCategory C
J : Type v
inst✝³ : SmallCategory J
F : J ⥤ C
inst✝² : PreservesColimit F (forget C)
B : C
α : Type v
X : α → C
f : (j : α) → B ⟶ X j
inst✝¹ : HasWidePushout B X f
inst✝ : PreservesColimit (wideSpan B X f) (forget C)
j : α
y : (forget C).obj ((wideSpan B X f).obj (some j))
⊢ (∃ y_1, (forget C).map (head f) y_1 = (forget C).map (colimit.ι (wideSpan B X f) (some j)) y) ∨
    ∃ i y_1, (forget C).map (ι f i) y_1 = (forget C).map (colimit.ι (wideSpan B X f) (some j)) y

tactic: use j, y
state_before: case intro.some.intro.h
C : Type u
inst✝⁵ : Category C
inst✝⁴ : ConcreteCategory C
J : Type v
inst✝³ : SmallCategory J
F : J ⥤ C
inst✝² : PreservesColimit F (forget C)
B : C
α : Type v
X : α → C
f : (j : α) → B ⟶ X j
inst✝¹ : HasWidePushout B X f
inst✝ : PreservesColimit (wideSpan B X f) (forget C)
j : α
y : (forget C).obj ((wideSpan B X f).obj (some j))
⊢ ∃ i y_1, (forget C).map (ι f i) y_1 = (forget C).map (colimit.ι (wideSpan B X f) (some j)) y
Theorem: IsNoetherian.injective_of_surjective_endomorphism
File: Mathlib/RingTheory/Noetherian.lean

tactic: obtain ⟨n, ne, w⟩ := IsNoetherian.exists_endomorphism_iterate_ker_inf_range_eq_bot f
state_before: R : Type u_1
M : Type u_2
P : Type ?u.268814
N : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : AddCommGroup P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
f : M →ₗ[R] M
s : Surjective ↑f
⊢ Injective ↑f

tactic: rw [LinearMap.range_eq_top.mpr (LinearMap.iterate_surjective s n), inf_top_eq,
  LinearMap.ker_eq_bot] at w
state_before: case intro.intro
R : Type u_1
M : Type u_2
P : Type ?u.268814
N : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : AddCommGroup P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
f : M →ₗ[R] M
s : Surjective ↑f
n : ℕ
ne : n ≠ 0
w : LinearMap.ker (f ^ n) ⊓ LinearMap.range (f ^ n) = ⊥
⊢ Injective ↑f

tactic: exact LinearMap.injective_of_iterate_injective ne w
state_before: case intro.intro
R : Type u_1
M : Type u_2
P : Type ?u.268814
N : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : AddCommGroup P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
f : M →ₗ[R] M
s : Surjective ↑f
n : ℕ
ne : n ≠ 0
w : Injective ↑(f ^ n)
⊢ Injective ↑f
Theorem: Set.Ici_disjoint_Iic
File: Mathlib/Data/Set/Intervals/Disjoint.lean

tactic: rw [Set.disjoint_iff_inter_eq_empty, Ici_inter_Iic, Icc_eq_empty_iff]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : Preorder α
a b c : α
⊢ Disjoint (Ici a) (Iic b) ↔ ¬a ≤ b
Theorem: ZMod.cast_sub_one
File: Mathlib/Data/ZMod/Basic.lean

tactic: split_ifs with hk
state_before: R : Type u_1
inst✝ : Ring R
n : ℕ
k : ZMod n
⊢ ↑(k - 1) = (if k = 0 then ↑n else ↑k) - 1

tactic: rw [hk, zero_sub, ZMod.cast_neg_one]
state_before: case inl
R : Type u_1
inst✝ : Ring R
n : ℕ
k : ZMod n
hk : k = 0
⊢ ↑(k - 1) = ↑n - 1

tactic: cases n
state_before: case inr
R : Type u_1
inst✝ : Ring R
n : ℕ
k : ZMod n
hk : ¬k = 0
⊢ ↑(k - 1) = ↑k - 1

tactic: dsimp [ZMod, ZMod.cast]
state_before: case inr.zero
R : Type u_1
inst✝ : Ring R
k : ZMod Nat.zero
hk : ¬k = 0
⊢ ↑(k - 1) = ↑k - 1

tactic: rw [Int.cast_sub, Int.cast_one]
state_before: case inr.zero
R : Type u_1
inst✝ : Ring R
k : ZMod Nat.zero
hk : ¬k = 0
⊢ ↑(k - 1) = ↑k - 1

tactic: dsimp [ZMod, ZMod.cast, ZMod.val]
state_before: case inr.succ
R : Type u_1
inst✝ : Ring R
n✝ : ℕ
k : ZMod (Nat.succ n✝)
hk : ¬k = 0
⊢ ↑(k - 1) = ↑k - 1

tactic: rw [Fin.coe_sub_one, if_neg]
state_before: case inr.succ
R : Type u_1
inst✝ : Ring R
n✝ : ℕ
k : ZMod (Nat.succ n✝)
hk : ¬k = 0
⊢ ↑↑(k - 1) = ↑↑k - 1

tactic: rw [Nat.cast_sub, Nat.cast_one]
state_before: case inr.succ
R : Type u_1
inst✝ : Ring R
n✝ : ℕ
k : ZMod (Nat.succ n✝)
hk : ¬k = 0
⊢ ↑(↑k - 1) = ↑↑k - 1

tactic: rwa [Fin.ext_iff, Fin.val_zero, ← Ne, ← Nat.one_le_iff_ne_zero] at hk
state_before: case inr.succ
R : Type u_1
inst✝ : Ring R
n✝ : ℕ
k : ZMod (Nat.succ n✝)
hk : ¬k = 0
⊢ 1 ≤ ↑k

tactic: exact hk
state_before: case inr.succ.hnc
R : Type u_1
inst✝ : Ring R
n✝ : ℕ
k : ZMod (Nat.succ n✝)
hk : ¬k = 0
⊢ ¬k = 0
Theorem: AddLECancellable.tsub_lt_tsub_right_of_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: apply hc.lt_tsub_of_add_lt_left
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : c ≤ a
h2 : a < b
⊢ a - c < b - c

tactic: rwa [add_tsub_cancel_of_le h]
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : c ≤ a
h2 : a < b
⊢ c + (a - c) < b
Theorem: List.replicate_dedup
File: Mathlib/Data/List/Dedup.lean

tactic: rw [replicate_succ, dedup_cons_of_mem (mem_replicate.2 ⟨n.succ_ne_zero, rfl⟩),
  replicate_dedup n.succ_ne_zero]
state_before: α : Type u
inst✝ : DecidableEq α
x : α
n : ℕ
x✝ : n + 2 ≠ 0
⊢ dedup (replicate (n + 2) x) = [x]
Theorem: Bool.not_and
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ (a b : Bool), (!decide ((a && b) = (!a || !b))) = true
Theorem: Matrix.toLin_apply
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: rw [Matrix.toLin'_apply, v₂.equivFun_symm_apply]
state_before: R : Type u_3
inst✝⁷ : CommSemiring R
l : Type ?u.1631986
m : Type u_1
n : Type u_2
inst✝⁶ : Fintype n
inst✝⁵ : Fintype m
inst✝⁴ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_4
inst✝³ : AddCommMonoid M₁
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M₁
inst✝ : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M : Matrix m n R
v : M₁
⊢ ↑(LinearEquiv.symm (Basis.equivFun v₂)) (↑(↑toLin' M) ↑(↑v₁.repr v)) = ∑ j : m, mulVec M (↑(↑v₁.repr v)) j • ↑v₂ j
Theorem: LinearLocallyFiniteOrder.le_succFn
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

tactic: rw [le_isGLB_iff (succFn_spec i), mem_lowerBounds]
state_before: ι : Type u_1
inst✝ : LinearOrder ι
i : ι
⊢ i ≤ succFn i

tactic: exact fun x hx ↦ le_of_lt hx
state_before: ι : Type u_1
inst✝ : LinearOrder ι
i : ι
⊢ ∀ (x : ι), x ∈ Set.Ioi i → i ≤ x
Theorem: Metric.diam_le_of_subset_closedBall
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp [mul_two, mul_comm]
state_before: α : Type u
β : Type v
X : Type ?u.538230
ι : Type ?u.538233
inst✝ : PseudoMetricSpace α
s : Set α
x y z : α
r : ℝ
hr : 0 ≤ r
h : s ⊆ closedBall x r
a : α
ha : a ∈ s
b : α
hb : b ∈ s
⊢ r + r = 2 * r
Theorem: finprod_eq_one_of_forall_eq_one
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: simp (config := { contextual := true }) [h]
state_before: α : Type u_2
β : Type ?u.210357
ι : Type ?u.210360
G : Type ?u.210363
M : Type u_1
N : Type ?u.210369
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α → M
h : ∀ (x : α), f x = 1
⊢ (∏ᶠ (i : α), f i) = 1
Theorem: MeasureTheory.withDensity_eq_zero
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [← lintegral_eq_zero_iff' hf, ← set_lintegral_univ, ← withDensity_apply _ MeasurableSet.univ,
  h, Measure.coe_zero, Pi.zero_apply]
state_before: α : Type u_1
β : Type ?u.1772355
γ : Type ?u.1772358
δ : Type ?u.1772361
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : AEMeasurable f
h : withDensity μ f = 0
⊢ f =ᶠ[ae μ] 0
Theorem: CategoryTheory.Abelian.Pseudoelement.pseudoZero_aux
File: Mathlib/CategoryTheory/Abelian/Pseudoelements.lean

tactic: simp [comm]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
P Q : C
f : Over P
x✝ : f ≈ Over.mk 0
R : C
p : R ⟶ f.left
q : R ⟶ (Over.mk 0).left
ep : Epi p
w✝ : Epi q
comm : p ≫ f.hom = q ≫ (Over.mk 0).hom
⊢ p ≫ f.hom = 0

tactic: rw [hf, Over.coe_hom, HasZeroMorphisms.comp_zero, HasZeroMorphisms.comp_zero]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
P Q : C
f : Over P
hf : f.hom = 0
⊢ biprod.fst ≫ f.hom = biprod.snd ≫ (Over.mk 0).hom