tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Adjunction.projective_of_map_projective
File: Mathlib/CategoryTheory/Preadditive/Projective.lean

tactic: haveI := Adjunction.leftAdjointPreservesColimits.{0, 0} adj
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝¹ : Full F
inst✝ : Faithful F
P : C
hP : Projective (F.obj P)
E✝ X✝ : C
f : P ⟶ X✝
g : E✝ ⟶ X✝
x✝ : Epi g
⊢ ∃ f', f' ≫ g = f

tactic: rcases (@hP).1 (F.map f) (F.map g) with ⟨f', hf'⟩
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝¹ : Full F
inst✝ : Faithful F
P : C
hP : Projective (F.obj P)
E✝ X✝ : C
f : P ⟶ X✝
g : E✝ ⟶ X✝
x✝ : Epi g
this : PreservesColimitsOfSize F
⊢ ∃ f', f' ≫ g = f

tactic: use adj.unit.app _ ≫ G.map f' ≫ (inv <| adj.unit.app _)
state_before: case intro
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝¹ : Full F
inst✝ : Faithful F
P : C
hP : Projective (F.obj P)
E✝ X✝ : C
f : P ⟶ X✝
g : E✝ ⟶ X✝
x✝ : Epi g
this : PreservesColimitsOfSize F
f' : F.obj P ⟶ F.obj E✝
hf' : f' ≫ F.map g = F.map f
⊢ ∃ f', f' ≫ g = f

tactic: refine' Faithful.map_injective (F := F) _
state_before: case intro
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝¹ : Full F
inst✝ : Faithful F
P : C
hP : Projective (F.obj P)
E✝ X✝ : C
f : P ⟶ X✝
g : E✝ ⟶ X✝
x✝ : Epi g
this : PreservesColimitsOfSize F
f' : F.obj P ⟶ F.obj E✝
hf' : f' ≫ F.map g = F.map f
⊢ (adj.unit.app P ≫ G.map f' ≫ inv (adj.unit.app E✝)) ≫ g = f

tactic: simpa
state_before: case intro
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝¹ : Full F
inst✝ : Faithful F
P : C
hP : Projective (F.obj P)
E✝ X✝ : C
f : P ⟶ X✝
g : E✝ ⟶ X✝
x✝ : Epi g
this : PreservesColimitsOfSize F
f' : F.obj P ⟶ F.obj E✝
hf' : f' ≫ F.map g = F.map f
⊢ F.map ((adj.unit.app P ≫ G.map f' ≫ inv (adj.unit.app E✝)) ≫ g) = F.map f
Theorem: MeasureTheory.measurePreserving_smul
File: Mathlib/MeasureTheory/Group/Action.lean

tactic: ext1 s hs
state_before: G : Type ?u.6308
M : Type u_2
α : Type u_1
s : Set α
m : MeasurableSpace α
inst✝³ : MeasurableSpace M
inst✝² : SMul M α
inst✝¹ : MeasurableSMul M α
c : M
μ : Measure α
inst✝ : SMulInvariantMeasure M α μ
⊢ map (fun x => c • x) μ = μ

tactic: rw [map_apply (measurable_const_smul c) hs]
state_before: case h
G : Type ?u.6308
M : Type u_2
α : Type u_1
s✝ : Set α
m : MeasurableSpace α
inst✝³ : MeasurableSpace M
inst✝² : SMul M α
inst✝¹ : MeasurableSMul M α
c : M
μ : Measure α
inst✝ : SMulInvariantMeasure M α μ
s : Set α
hs : MeasurableSet s
⊢ ↑↑(map (fun x => c • x) μ) s = ↑↑μ s

tactic: exact SMulInvariantMeasure.measure_preimage_smul c hs
state_before: case h
G : Type ?u.6308
M : Type u_2
α : Type u_1
s✝ : Set α
m : MeasurableSpace α
inst✝³ : MeasurableSpace M
inst✝² : SMul M α
inst✝¹ : MeasurableSMul M α
c : M
μ : Measure α
inst✝ : SMulInvariantMeasure M α μ
s : Set α
hs : MeasurableSet s
⊢ ↑↑μ ((fun x x_1 => x • x_1) c ⁻¹' s) = ↑↑μ s
Theorem: Ideal.radical_eq_sInf
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rintro rfl
state_before: R : Type u
ι : Type ?u.327198
inst✝ : CommSemiring R
I✝ J K L I : Ideal R
r : R
hr : r ∈ sInf {J | I ≤ J ∧ IsPrime J}
hri : ¬r ∈ radical I
m : Ideal R
hrm : ¬r ∈ radical m
him : I ≤ m
hm : ∀ (z : Ideal R), z ∈ {K | ¬r ∈ radical K} → m ≤ z → z = m
this : ∀ (x : R), ¬x ∈ m → r ∈ radical (m ⊔ span {x})
⊢ m ≠ ⊤

tactic: rw [radical_top] at hrm
state_before: R : Type u
ι : Type ?u.327198
inst✝ : CommSemiring R
I✝ J K L I : Ideal R
r : R
hr : r ∈ sInf {J | I ≤ J ∧ IsPrime J}
hri : ¬r ∈ radical I
hrm : ¬r ∈ radical ⊤
him : I ≤ ⊤
hm : ∀ (z : Ideal R), z ∈ {K | ¬r ∈ radical K} → ⊤ ≤ z → z = ⊤
this : ∀ (x : R), ¬x ∈ ⊤ → r ∈ radical (⊤ ⊔ span {x})
⊢ False

tactic: exact hrm trivial
state_before: R : Type u
ι : Type ?u.327198
inst✝ : CommSemiring R
I✝ J K L I : Ideal R
r : R
hr : r ∈ sInf {J | I ≤ J ∧ IsPrime J}
hri : ¬r ∈ radical I
hrm : ¬r ∈ ⊤
him : I ≤ ⊤
hm : ∀ (z : Ideal R), z ∈ {K | ¬r ∈ radical K} → ⊤ ≤ z → z = ⊤
this : ∀ (x : R), ¬x ∈ ⊤ → r ∈ radical (⊤ ⊔ span {x})
⊢ False

tactic: rw [pow_add, ← hpqrn, ← hcxq, ← hfgrk, ← hdyg, add_mul, mul_add (c * x),
    mul_assoc c x (d * y), mul_left_comm x, ← mul_assoc]
state_before: R : Type u
ι : Type ?u.327198
inst✝ : CommSemiring R
I✝ J K L I : Ideal R
r : R
hr : r ∈ sInf {J | I ≤ J ∧ IsPrime J}
hri : ¬r ∈ radical I
m : Ideal R
hrm : ¬r ∈ radical m
him : I ≤ m
hm : ∀ (z : Ideal R), z ∈ {K | ¬r ∈ radical K} → m ≤ z → z = m
this : ∀ (x : R), ¬x ∈ m → r ∈ radical (m ⊔ span {x})
x y : R
hxym : x * y ∈ m
hxm : ¬x ∈ m
hym : ¬y ∈ m
n : ℕ
hrn : r ^ n ∈ m ⊔ span {x}
p : R
hpm : p ∈ m
q : R
hq : q ∈ span {x}
hpqrn : p + q = r ^ n
c : R
hcxq : c * x = q
k : ℕ
hrk : r ^ k ∈ m ⊔ span {y}
f : R
hfm : f ∈ m
g : R
hg : g ∈ span {y}
hfgrk : f + g = r ^ k
d : R
hdyg : d * y = g
⊢ r ^ (n + k) ∈ m

tactic: refine'
  m.add_mem (m.mul_mem_right _ hpm)
    (m.add_mem (m.mul_mem_left _ hfm) (m.mul_mem_left _ hxym))
state_before: R : Type u
ι : Type ?u.327198
inst✝ : CommSemiring R
I✝ J K L I : Ideal R
r : R
hr : r ∈ sInf {J | I ≤ J ∧ IsPrime J}
hri : ¬r ∈ radical I
m : Ideal R
hrm : ¬r ∈ radical m
him : I ≤ m
hm : ∀ (z : Ideal R), z ∈ {K | ¬r ∈ radical K} → m ≤ z → z = m
this : ∀ (x : R), ¬x ∈ m → r ∈ radical (m ⊔ span {x})
x y : R
hxym : x * y ∈ m
hxm : ¬x ∈ m
hym : ¬y ∈ m
n : ℕ
hrn : r ^ n ∈ m ⊔ span {x}
p : R
hpm : p ∈ m
q : R
hq : q ∈ span {x}
hpqrn : p + q = r ^ n
c : R
hcxq : c * x = q
k : ℕ
hrk : r ^ k ∈ m ⊔ span {y}
f : R
hfm : f ∈ m
g : R
hg : g ∈ span {y}
hfgrk : f + g = r ^ k
d : R
hdyg : d * y = g
⊢ p * (f + d * y) + (c * x * f + c * d * (x * y)) ∈ m
Theorem: QuotientGroup.preimage_image_mk
File: Mathlib/GroupTheory/Coset.lean

tactic: ext x
state_before: α : Type u_1
inst✝ : Group α
s✝ : Subgroup α
a b : α
N : Subgroup α
s : Set α
⊢ mk ⁻¹' (mk '' s) = ⋃ (x : { x // x ∈ N }), (fun y => y * ↑x) ⁻¹' s

tactic: simp only [QuotientGroup.eq, SetLike.exists, exists_prop, Set.mem_preimage, Set.mem_iUnion,
  Set.mem_image, ← eq_inv_mul_iff_mul_eq]
state_before: case h
α : Type u_1
inst✝ : Group α
s✝ : Subgroup α
a b : α
N : Subgroup α
s : Set α
x : α
⊢ x ∈ mk ⁻¹' (mk '' s) ↔ x ∈ ⋃ (x : { x // x ∈ N }), (fun y => y * ↑x) ⁻¹' s

tactic: exact
  ⟨fun ⟨y, hs, hN⟩ => ⟨_, N.inv_mem hN, by simpa using hs⟩, fun ⟨z, hz, hxz⟩ =>
    ⟨x * z, hxz, by simpa using hz⟩⟩
state_before: case h
α : Type u_1
inst✝ : Group α
s✝ : Subgroup α
a b : α
N : Subgroup α
s : Set α
x : α
⊢ (∃ x_1, x_1 ∈ s ∧ x_1⁻¹ * x ∈ N) ↔ ∃ x_1, x_1 ∈ N ∧ x * x_1 ∈ s

tactic: simpa using hs
state_before: α : Type u_1
inst✝ : Group α
s✝ : Subgroup α
a b : α
N : Subgroup α
s : Set α
x : α
x✝ : ∃ x_1, x_1 ∈ s ∧ x_1⁻¹ * x ∈ N
y : α
hs : y ∈ s
hN : y⁻¹ * x ∈ N
⊢ x * (y⁻¹ * x)⁻¹ ∈ s

tactic: simpa using hz
state_before: α : Type u_1
inst✝ : Group α
s✝ : Subgroup α
a b : α
N : Subgroup α
s : Set α
x : α
x✝ : ∃ x_1, x_1 ∈ N ∧ x * x_1 ∈ s
z : α
hz : z ∈ N
hxz : x * z ∈ s
⊢ (x * z)⁻¹ * x ∈ N
Theorem: ProbabilityTheory.IndepSets.bUnion
File: Mathlib/Probability/Independence/Basic.lean

tactic: intro t1 t2 ht1 ht2
state_before: Ω : Type u_1
ι : Type u_2
inst✝ : MeasurableSpace Ω
s : ι → Set (Set Ω)
s' : Set (Set Ω)
μ : MeasureTheory.Measure Ω
u : Set ι
hyp : ∀ (n : ι), n ∈ u → IndepSets (s n) s'
⊢ IndepSets (⋃ (n : ι) (_ : n ∈ u), s n) s'

tactic: simp_rw [Set.mem_iUnion] at ht1
state_before: Ω : Type u_1
ι : Type u_2
inst✝ : MeasurableSpace Ω
s : ι → Set (Set Ω)
s' : Set (Set Ω)
μ : MeasureTheory.Measure Ω
u : Set ι
hyp : ∀ (n : ι), n ∈ u → IndepSets (s n) s'
t1 t2 : Set Ω
ht1 : t1 ∈ ⋃ (n : ι) (_ : n ∈ u), s n
ht2 : t2 ∈ s'
⊢ ↑↑μ (t1 ∩ t2) = ↑↑μ t1 * ↑↑μ t2

tactic: rcases ht1 with ⟨n, hpn, ht1⟩
state_before: Ω : Type u_1
ι : Type u_2
inst✝ : MeasurableSpace Ω
s : ι → Set (Set Ω)
s' : Set (Set Ω)
μ : MeasureTheory.Measure Ω
u : Set ι
hyp : ∀ (n : ι), n ∈ u → IndepSets (s n) s'
t1 t2 : Set Ω
ht2 : t2 ∈ s'
ht1 : ∃ i i_1, t1 ∈ s i
⊢ ↑↑μ (t1 ∩ t2) = ↑↑μ t1 * ↑↑μ t2

tactic: exact hyp n hpn t1 t2 ht1 ht2
state_before: case intro.intro
Ω : Type u_1
ι : Type u_2
inst✝ : MeasurableSpace Ω
s : ι → Set (Set Ω)
s' : Set (Set Ω)
μ : MeasureTheory.Measure Ω
u : Set ι
hyp : ∀ (n : ι), n ∈ u → IndepSets (s n) s'
t1 t2 : Set Ω
ht2 : t2 ∈ s'
n : ι
hpn : n ∈ u
ht1 : t1 ∈ s n
⊢ ↑↑μ (t1 ∩ t2) = ↑↑μ t1 * ↑↑μ t2
Theorem: ContinuousMap.Homotopy.extend_apply_of_le_zero
File: Mathlib/Topology/Homotopy/Basic.lean

tactic: rw [← F.apply_zero]
state_before: F✝ : Type ?u.9922
X : Type u
Y : Type v
Z : Type w
Z' : Type x
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
f₀ f₁ : C(X, Y)
F : Homotopy f₀ f₁
t : ℝ
ht : t ≤ 0
x : X
⊢ ↑(↑(extend F) t) x = ↑f₀ x

tactic: exact ContinuousMap.congr_fun (Set.IccExtend_of_le_left (zero_le_one' ℝ) F.curry ht) x
state_before: F✝ : Type ?u.9922
X : Type u
Y : Type v
Z : Type w
Z' : Type x
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
f₀ f₁ : C(X, Y)
F : Homotopy f₀ f₁
t : ℝ
ht : t ≤ 0
x : X
⊢ ↑(↑(extend F) t) x = ↑F (0, x)
Theorem: Multiset.card_Iic
File: Mathlib/Data/Multiset/Interval.lean

tactic: simp_rw [Iic_eq_Icc, card_Icc, bot_eq_zero, toFinset_zero, empty_union, count_zero, tsub_zero]
state_before: α : Type u_1
β : α → Type ?u.47784
inst✝ : DecidableEq α
f g : Multiset α
⊢ Finset.card (Finset.Iic f) = ∏ i in toFinset f, (count i f + 1)
Theorem: Array.get_push_lt
File: Std/Data/Array/Init/Lemmas.lean

tactic: simp [*, Nat.lt_succ_of_le, Nat.le_of_lt]
state_before: α : Type ?u.44886
a : Array α
x : α
i : Nat
h : i < size a
⊢ i < size (push a x)

tactic: simp only [push, getElem_eq_data_get, List.concat_eq_append, List.get_append_left, h]
state_before: α : Type u_1
a : Array α
x : α
i : Nat
h : i < size a
⊢ (push a x)[i] = a[i]
Theorem: Function.Periodic.div_const
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [div_eq_mul_inv] using h.mul_const_inv a
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.72900
f g : α → β
c c₁ c₂ x : α
inst✝ : DivisionSemiring α
h : Periodic f c
a : α
⊢ Periodic (fun x => f (x / a)) (c * a)
Theorem: PGame.add_moveLeft_inr
File: Mathlib/SetTheory/Game/PGame.lean

tactic: cases x
state_before: x y : PGame
i : LeftMoves y
⊢ moveLeft (x + y) (↑toLeftMovesAdd (Sum.inr i)) = x + moveLeft y i

tactic: cases y
state_before: case mk
y : PGame
i : LeftMoves y
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ moveLeft (mk α✝ β✝ a✝¹ a✝ + y) (↑toLeftMovesAdd (Sum.inr i)) = mk α✝ β✝ a✝¹ a✝ + moveLeft y i

tactic: rfl
state_before: case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : LeftMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveLeft (mk α✝¹ β✝¹ a✝³ a✝² + mk α✝ β✝ a✝¹ a✝) (↑toLeftMovesAdd (Sum.inr i)) =
    mk α✝¹ β✝¹ a✝³ a✝² + moveLeft (mk α✝ β✝ a✝¹ a✝) i
Theorem: Matrix.zero_mul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type u_3
m : Type u_1
n : Type u_2
o : Type ?u.265366
m' : o → Type ?u.265371
n' : o → Type ?u.265376
R : Type ?u.265379
S : Type ?u.265382
α : Type v
β : Type w
γ : Type ?u.265389
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype m
M : Matrix m n α
⊢ 0 ⬝ M = 0

tactic: apply zero_dotProduct
state_before: case a.h
l : Type u_3
m : Type u_1
n : Type u_2
o : Type ?u.265366
m' : o → Type ?u.265371
n' : o → Type ?u.265376
R : Type ?u.265379
S : Type ?u.265382
α : Type v
β : Type w
γ : Type ?u.265389
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype m
M : Matrix m n α
i✝ : l
x✝ : n
⊢ (0 ⬝ M) i✝ x✝ = OfNat.ofNat 0 i✝ x✝
Theorem: Computation.results_thinkN_pure
File: Mathlib/Data/Seq/Computation.lean

tactic: have := results_thinkN n (results_pure a)
state_before: α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
⊢ Results (thinkN (pure a) n) a n

tactic: rwa [Nat.zero_add] at this
state_before: α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
this : Results (thinkN (pure a) n) a (0 + n)
⊢ Results (thinkN (pure a) n) a n
Theorem: Zspan.coe_fract_self
File: Mathlib/Algebra/Module/Zlattice.lean

tactic: rw [repr_fract_apply, Basis.singleton_repr, Basis.singleton_repr]
state_before: E : Type ?u.332864
ι : Type u_2
K : Type u_1
inst✝⁵ : NormedLinearOrderedField K
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace K E
b : Basis ι K E
inst✝² : FloorRing K
inst✝¹ : Fintype ι
inst✝ : Unique ι
k : K
x✝ : ?m.334629 k
⊢ ↑(↑(?m.334633 k).repr (fract (Basis.singleton ι K) k)) x✝ = ↑(↑(?m.334633 k).repr (Int.fract k)) x✝
Theorem: Submodule.torsionBySet_eq_torsionBySet_span
File: Mathlib/Algebra/Module/Torsion.lean

tactic: refine le_antisymm (fun x hx => ?_) (torsionBySet_le_torsionBySet_of_subset subset_span)
state_before: R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
⊢ torsionBySet R M s = torsionBySet R M ↑(Ideal.span s)

tactic: rw [mem_torsionBySet_iff] at hx ⊢
state_before: R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
x : M
hx : x ∈ torsionBySet R M s
⊢ x ∈ torsionBySet R M ↑(Ideal.span s)

tactic: suffices Ideal.span s ≤ Ideal.torsionOf R M x by
  rintro ⟨a, ha⟩
  exact this ha
state_before: R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
x : M
hx : ∀ (a : ↑s), ↑a • x = 0
⊢ ∀ (a : ↑↑(Ideal.span s)), ↑a • x = 0

tactic: rw [Ideal.span_le]
state_before: R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
x : M
hx : ∀ (a : ↑s), ↑a • x = 0
⊢ Ideal.span s ≤ Ideal.torsionOf R M x

tactic: exact fun a ha => hx ⟨a, ha⟩
state_before: R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
x : M
hx : ∀ (a : ↑s), ↑a • x = 0
⊢ s ⊆ ↑(Ideal.torsionOf R M x)

tactic: rintro ⟨a, ha⟩
state_before: R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
x : M
hx : ∀ (a : ↑s), ↑a • x = 0
this : Ideal.span s ≤ Ideal.torsionOf R M x
⊢ ∀ (a : ↑↑(Ideal.span s)), ↑a • x = 0

tactic: exact this ha
state_before: case mk
R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a✝ : R
x : M
hx : ∀ (a : ↑s), ↑a • x = 0
this : Ideal.span s ≤ Ideal.torsionOf R M x
a : R
ha : a ∈ ↑(Ideal.span s)
⊢ ↑{ val := a, property := ha } • x = 0
Theorem: MeasureTheory.Lp.simpleFunc.smul_toSimpleFunc
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: filter_upwards [toSimpleFunc_eq_toFun (k • f), toSimpleFunc_eq_toFun f,
  Lp.coeFn_smul k (f : Lp E p μ)] with _
state_before: α : Type u_1
β : Type ?u.1594821
ι : Type ?u.1594824
E : Type u_2
F : Type ?u.1594830
𝕜 : Type u_3
inst✝⁵ : MeasurableSpace α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : BoundedSMul 𝕜 E
k : 𝕜
f : { x // x ∈ simpleFunc E p μ }
⊢ ↑(toSimpleFunc (k • f)) =ᵐ[μ] k • ↑(toSimpleFunc f)

tactic: simp only [Pi.smul_apply, coe_smul]
state_before: case h
α : Type u_1
β : Type ?u.1594821
ι : Type ?u.1594824
E : Type u_2
F : Type ?u.1594830
𝕜 : Type u_3
inst✝⁵ : MeasurableSpace α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : BoundedSMul 𝕜 E
k : 𝕜
f : { x // x ∈ simpleFunc E p μ }
a✝ : α
⊢ ↑(toSimpleFunc (k • f)) a✝ = ↑↑↑(k • f) a✝ →
    ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝ →
      ↑↑(k • ↑f) a✝ = (k • ↑↑↑f) a✝ → ↑(toSimpleFunc (k • f)) a✝ = (k • ↑(toSimpleFunc f)) a✝

tactic: repeat intro h; rw [h]
state_before: case h
α : Type u_1
β : Type ?u.1594821
ι : Type ?u.1594824
E : Type u_2
F : Type ?u.1594830
𝕜 : Type u_3
inst✝⁵ : MeasurableSpace α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : BoundedSMul 𝕜 E
k : 𝕜
f : { x // x ∈ simpleFunc E p μ }
a✝ : α
⊢ ↑(toSimpleFunc (k • f)) a✝ = ↑↑(k • ↑f) a✝ →
    ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝ → ↑↑(k • ↑f) a✝ = k • ↑↑↑f a✝ → ↑(toSimpleFunc (k • f)) a✝ = k • ↑(toSimpleFunc f) a✝

tactic: rw [h]
state_before: case h
α : Type u_1
β : Type ?u.1594821
ι : Type ?u.1594824
E : Type u_2
F : Type ?u.1594830
𝕜 : Type u_3
inst✝⁵ : MeasurableSpace α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : BoundedSMul 𝕜 E
k : 𝕜
f : { x // x ∈ simpleFunc E p μ }
a✝ : α
h✝¹ : ↑(toSimpleFunc (k • f)) a✝ = ↑↑(k • ↑f) a✝
h✝ : ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝
h : ↑↑(k • ↑f) a✝ = k • ↑↑↑f a✝
⊢ ↑↑(k • ↑f) a✝ = k • ↑↑↑f a✝
Theorem: Set.Iic_iInf₂
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [Iic_iInf]
state_before: α : Type u_1
β : Type ?u.296897
γ : Type ?u.296900
ι : Sort u_2
ι' : Sort ?u.296906
ι₂ : Sort ?u.296909
κ : ι → Sort u_3
κ₁ : ι → Sort ?u.296919
κ₂ : ι → Sort ?u.296924
κ' : ι' → Sort ?u.296929
inst✝ : CompleteLattice α
f : (i : ι) → κ i → α
⊢ Iic (⨅ (i : ι) (j : κ i), f i j) = ⋂ (i : ι) (j : κ i), Iic (f i j)
Theorem: ConvexOn.map_centerMass_le
File: Mathlib/Analysis/Convex/Jensen.lean

tactic: have hmem' : ∀ i ∈ t, (p i, (f ∘ p) i) ∈ { p : E × β | p.1 ∈ s ∧ f p.1 ≤ p.2 } := fun i hi =>
  ⟨hmem i hi, le_rfl⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.962
β : Type u_3
ι : Type u_4
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : OrderedAddCommGroup β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
t : Finset ι
w : ι → 𝕜
p : ι → E
hf : ConvexOn 𝕜 s f
h₀ : ∀ (i : ι), i ∈ t → 0 ≤ w i
h₁ : 0 < ∑ i in t, w i
hmem : ∀ (i : ι), i ∈ t → p i ∈ s
⊢ f (centerMass t w p) ≤ centerMass t w (f ∘ p)

tactic: convert(hf.convex_epigraph.centerMass_mem h₀ h₁ hmem').2 <;>
  simp only [centerMass, Function.comp, Prod.smul_fst, Prod.fst_sum, Prod.smul_snd, Prod.snd_sum]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.962
β : Type u_3
ι : Type u_4
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : OrderedAddCommGroup β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
t : Finset ι
w : ι → 𝕜
p : ι → E
hf : ConvexOn 𝕜 s f
h₀ : ∀ (i : ι), i ∈ t → 0 ≤ w i
h₁ : 0 < ∑ i in t, w i
hmem : ∀ (i : ι), i ∈ t → p i ∈ s
hmem' : ∀ (i : ι), i ∈ t → (p i, (f ∘ p) i) ∈ {p | p.fst ∈ s ∧ f p.fst ≤ p.snd}
⊢ f (centerMass t w p) ≤ centerMass t w (f ∘ p)
Theorem: List.cons_head?_tail
File: Mathlib/Data/List/Basic.lean

tactic: contradiction
state_before: ι : Type ?u.43589
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
h : a ∈ head? []
⊢ a :: tail [] = []

tactic: simp at h
state_before: ι : Type ?u.43589
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
b : α
l : List α
a : α
h : a ∈ head? (b :: l)
⊢ a :: tail (b :: l) = b :: l

tactic: simp [h]
state_before: ι : Type ?u.43589
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
b : α
l : List α
a : α
h : b = a
⊢ a :: tail (b :: l) = b :: l
Theorem: NonUnitalAlgHom.coe_mulHom_mk
File: Mathlib/Algebra/Hom/NonUnitalAlg.lean

tactic: rfl
state_before: R : Type u
A : Type v
B : Type w
C : Type w₁
inst✝⁶ : Monoid R
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction R B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction R C
f : A →ₙₐ[R] B
h₁ : ∀ (m : R) (x : A), ↑f (m • x) = m • ↑f x
h₂ : MulActionHom.toFun { toFun := ↑f, map_smul' := h₁ } 0 = 0
h₃ :
  ∀ (x y : A),
    MulActionHom.toFun { toFun := ↑f, map_smul' := h₁ } (x + y) =
      MulActionHom.toFun { toFun := ↑f, map_smul' := h₁ } x + MulActionHom.toFun { toFun := ↑f, map_smul' := h₁ } y
h₄ :
  ∀ (x y : A),
    MulActionHom.toFun
        { toMulActionHom := { toFun := ↑f, map_smul' := h₁ }, map_zero' := h₂, map_add' := h₃ }.toMulActionHom (x * y) =
      MulActionHom.toFun
          { toMulActionHom := { toFun := ↑f, map_smul' := h₁ }, map_zero' := h₂, map_add' := h₃ }.toMulActionHom x *
        MulActionHom.toFun
          { toMulActionHom := { toFun := ↑f, map_smul' := h₁ }, map_zero' := h₂, map_add' := h₃ }.toMulActionHom y
⊢ ↑{ toDistribMulActionHom := { toMulActionHom := { toFun := ↑f, map_smul' := h₁ }, map_zero' := h₂, map_add' := h₃ },
        map_mul' := h₄ } =
    { toFun := ↑f, map_mul' := h₄ }
Theorem: CategoryTheory.mono_iff_exact_zero_left
File: Mathlib/Algebra/Homology/Exact.lean

tactic: simpa using h.epi
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A B✝ C✝ D : V
f✝ : A ⟶ B✝
g : B✝ ⟶ C✝
h✝ : C✝ ⟶ D
inst✝² : HasZeroObject V
inst✝¹ : Preadditive V
inst✝ : HasKernels V
B C : V
f : B ⟶ C
h : Exact 0 f
⊢ Epi 0
Theorem: Continuous.exists_forall_le'
File: Mathlib/Topology/Algebra/Order/Compact.lean

tactic: rwa [principal_univ, inf_top_eq]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.46391
inst✝⁴ : ConditionallyCompleteLinearOrder α
inst✝³ : TopologicalSpace α
inst✝² : OrderTopology α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : β → α
hf : Continuous f
x₀ : β
h : ∀ᶠ (x : β) in cocompact β, f x₀ ≤ f x
⊢ ∀ᶠ (x : β) in cocompact β ⊓ 𝓟 univ, f x₀ ≤ f x
Theorem: List.drop_append_of_le_length
File: Mathlib/Data/List/Basic.lean

tactic: simp [drop_append_eq_append_drop, tsub_eq_zero_iff_le.mpr h]
state_before: ι : Type ?u.206668
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ l₁ l₂ : List α
n : ℕ
h : n ≤ length l₁
⊢ drop n (l₁ ++ l₂) = drop n l₁ ++ l₂
Theorem: Finset.eq_of_veq
File: Mathlib/Data/Finset/Basic.lean

tactic: cases h
state_before: α : Type u_1
β : Type ?u.551
γ : Type ?u.554
s : Multiset α
nodup✝¹ : Nodup s
t : Multiset α
nodup✝ : Nodup t
h : { val := s, nodup := nodup✝¹ }.val = { val := t, nodup := nodup✝ }.val
⊢ { val := s, nodup := nodup✝¹ } = { val := t, nodup := nodup✝ }

tactic: rfl
state_before: case refl
α : Type u_1
β : Type ?u.551
γ : Type ?u.554
s : Multiset α
nodup✝¹ nodup✝ : Nodup s
⊢ { val := s, nodup := nodup✝¹ } = { val := s, nodup := nodup✝ }
Theorem: Cardinal.mk_univ_quaternionAlgebra
File: Mathlib/Algebra/Quaternion.lean

tactic: rw [mk_univ, mk_quaternionAlgebra]
state_before: R : Type u_1
c₁ c₂ : R
⊢ (#↑Set.univ) = (#R) ^ 4
Theorem: LieModuleHom.mk_coe
File: Mathlib/Algebra/Lie/Basic.lean

tactic: rfl
state_before: R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : M →ₗ⁅R,L⁆ N
h : ∀ {x : L} {m : M}, AddHom.toFun f.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun f.toAddHom m⁆
⊢ { toLinearMap := ↑f, map_lie' := h } = f
Theorem: Complex.abs_cast_nat
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [← ofReal_nat_cast, abs_of_nonneg (Nat.cast_nonneg n)]
state_before: n : ℕ
⊢ ↑abs ↑n = ↑n
Theorem: RelEmbedding.exists_not_acc_lt_of_not_acc
File: Mathlib/Order/OrderIsoNat.lean

tactic: contrapose! h
state_before: α : Type u_1
r✝ : α → α → Prop
inst✝ : IsStrictOrder α r✝
a : α
r : α → α → Prop
h : ¬Acc r a
⊢ ∃ b, ¬Acc r b ∧ r b a

tactic: refine' ⟨_, fun b hr => _⟩
state_before: α : Type u_1
r✝ : α → α → Prop
inst✝ : IsStrictOrder α r✝
a : α
r : α → α → Prop
h : ∀ (b : α), ¬Acc r b → ¬r b a
⊢ Acc r a

tactic: by_contra hb
state_before: α : Type u_1
r✝ : α → α → Prop
inst✝ : IsStrictOrder α r✝
a : α
r : α → α → Prop
h : ∀ (b : α), ¬Acc r b → ¬r b a
b : α
hr : r b a
⊢ Acc r b

tactic: exact h b hb hr
state_before: α : Type u_1
r✝ : α → α → Prop
inst✝ : IsStrictOrder α r✝
a : α
r : α → α → Prop
h : ∀ (b : α), ¬Acc r b → ¬r b a
b : α
hr : r b a
hb : ¬Acc r b
⊢ False
Theorem: Polynomial.degree_one_le
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [← C_1]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ degree 1 ≤ 0

tactic: exact degree_C_le
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ degree (↑C 1) ≤ 0
Theorem: Ordinal.lift_nat_cast
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp
state_before: ⊢ lift ↑0 = ↑0

tactic: simp [lift_nat_cast n]
state_before: n : ℕ
⊢ lift ↑(n + 1) = ↑(n + 1)