tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.setToFun_congr_left'
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: by_cases hf : Integrable f μ
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1337567
G : Type ?u.1337570
𝕜 : Type ?u.1337573
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
h : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T s = T' s
f : α → E
⊢ setToFun μ T hT f = setToFun μ T' hT' f

tactic: simp_rw [setToFun_eq _ hf, L1.setToL1_congr_left' T T' hT hT' h]
state_before: case pos
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1337567
G : Type ?u.1337570
𝕜 : Type ?u.1337573
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
h : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T s = T' s
f : α → E
hf : Integrable f
⊢ setToFun μ T hT f = setToFun μ T' hT' f

tactic: simp_rw [setToFun_undef _ hf]
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1337567
G : Type ?u.1337570
𝕜 : Type ?u.1337573
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
h : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T s = T' s
f : α → E
hf : ¬Integrable f
⊢ setToFun μ T hT f = setToFun μ T' hT' f
Theorem: Cardinal.card_le_of
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: refine' le_of_lt_succ (lt_of_not_ge fun hn => _)
state_before: α✝ β α : Type u
n : ℕ
H : ∀ (s : Finset α), Finset.card s ≤ n
⊢ (#α) ≤ ↑n

tactic: rw [← Cardinal.nat_succ, ← lift_mk_fin n.succ] at hn
state_before: α✝ β α : Type u
n : ℕ
H : ∀ (s : Finset α), Finset.card s ≤ n
hn : (#α) ≥ succ ↑n
⊢ False

tactic: cases' hn with f
state_before: α✝ β α : Type u
n : ℕ
H : ∀ (s : Finset α), Finset.card s ≤ n
hn : (#α) ≥ lift (#Fin (Nat.succ n))
⊢ False

tactic: refine' (H <| Finset.univ.map f).not_lt _
state_before: case intro
α✝ β α : Type u
n : ℕ
H : ∀ (s : Finset α), Finset.card s ≤ n
f : ULift (Fin (Nat.succ n)) ↪ α
⊢ False

tactic: rw [Finset.card_map, ← Fintype.card, Fintype.card_ulift, Fintype.card_fin]
state_before: case intro
α✝ β α : Type u
n : ℕ
H : ∀ (s : Finset α), Finset.card s ≤ n
f : ULift (Fin (Nat.succ n)) ↪ α
⊢ n < Finset.card (Finset.map f Finset.univ)

tactic: exact n.lt_succ_self
state_before: case intro
α✝ β α : Type u
n : ℕ
H : ∀ (s : Finset α), Finset.card s ≤ n
f : ULift (Fin (Nat.succ n)) ↪ α
⊢ n < Nat.succ n
Theorem: EMetric.diam_pos_iff
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: simp only [pos_iff_ne_zero, Ne.def, diam_eq_zero_iff, Set.not_subsingleton_iff]
state_before: α : Type u
β : Type v
X : Type ?u.314348
inst✝¹ : PseudoEMetricSpace α
γ : Type w
inst✝ : EMetricSpace γ
s : Set γ
⊢ 0 < diam s ↔ Set.Nontrivial s
Theorem: Multiset.disjoint_union_left
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [Disjoint, or_imp, forall_and]
state_before: α : Type u_1
β : Type ?u.498034
γ : Type ?u.498037
inst✝ : DecidableEq α
s t u : Multiset α
⊢ Disjoint (s ∪ t) u ↔ Disjoint s u ∧ Disjoint t u
Theorem: Cardinal.cantor
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: induction' a using Cardinal.inductionOn with α
state_before: α β : Type u
a : Cardinal
⊢ a < 2 ^ a

tactic: rw [← mk_set]
state_before: case h
α✝ β α : Type u
⊢ (#α) < 2 ^ (#α)

tactic: refine' ⟨⟨⟨singleton, fun a b => singleton_eq_singleton_iff.1⟩⟩, _⟩
state_before: case h
α✝ β α : Type u
⊢ (#α) < (#Set α)

tactic: rintro ⟨⟨f, hf⟩⟩
state_before: case h
α✝ β α : Type u
⊢ ¬Quotient.liftOn₂ (#Set α) (#α) (fun α β => Nonempty (α ↪ β)) instLECardinal.proof_1

tactic: exact cantor_injective f hf
state_before: case h.intro.mk
α✝ β α : Type u
f : Set α → α
hf : Injective f
⊢ False
Theorem: ENNReal.exists_mem_Ico_zpow
File: Mathlib/Data/Real/ENNReal.lean

tactic: lift x to ℝ≥0 using h'x
state_before: α : Type ?u.460337
β : Type ?u.460340
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y : ℝ≥0∞
hx : x ≠ 0
h'x : x ≠ ⊤
hy : 1 < y
h'y : y ≠ ⊤
⊢ ∃ n, x ∈ Ico (y ^ n) (y ^ (n + 1))

tactic: lift y to ℝ≥0 using h'y
state_before: case intro
α : Type ?u.460337
β : Type ?u.460340
a b c d : ℝ≥0∞
r p q : ℝ≥0
y : ℝ≥0∞
hy : 1 < y
h'y : y ≠ ⊤
x : ℝ≥0
hx : ↑x ≠ 0
⊢ ∃ n, ↑x ∈ Ico (y ^ n) (y ^ (n + 1))

tactic: have A : y ≠ 0 := by simpa only [Ne.def, coe_eq_zero] using (zero_lt_one.trans hy).ne'
state_before: case intro.intro
α : Type ?u.460337
β : Type ?u.460340
a b c d : ℝ≥0∞
r p q x : ℝ≥0
hx : ↑x ≠ 0
y : ℝ≥0
hy : 1 < ↑y
⊢ ∃ n, ↑x ∈ Ico (↑y ^ n) (↑y ^ (n + 1))

tactic: obtain ⟨n, hn, h'n⟩ : ∃ n : ℤ, y ^ n ≤ x ∧ x < y ^ (n + 1) := by
  refine' NNReal.exists_mem_Ico_zpow _ (one_lt_coe_iff.1 hy)
  simpa only [Ne.def, coe_eq_zero] using hx
state_before: case intro.intro
α : Type ?u.460337
β : Type ?u.460340
a b c d : ℝ≥0∞
r p q x : ℝ≥0
hx : ↑x ≠ 0
y : ℝ≥0
hy : 1 < ↑y
A : y ≠ 0
⊢ ∃ n, ↑x ∈ Ico (↑y ^ n) (↑y ^ (n + 1))

tactic: refine' ⟨n, _, _⟩
state_before: case intro.intro.intro.intro
α : Type ?u.460337
β : Type ?u.460340
a b c d : ℝ≥0∞
r p q x : ℝ≥0
hx : ↑x ≠ 0
y : ℝ≥0
hy : 1 < ↑y
A : y ≠ 0
n : ℤ
hn : y ^ n ≤ x
h'n : x < y ^ (n + 1)
⊢ ∃ n, ↑x ∈ Ico (↑y ^ n) (↑y ^ (n + 1))

tactic: simpa only [Ne.def, coe_eq_zero] using (zero_lt_one.trans hy).ne'
state_before: α : Type ?u.460337
β : Type ?u.460340
a b c d : ℝ≥0∞
r p q x : ℝ≥0
hx : ↑x ≠ 0
y : ℝ≥0
hy : 1 < ↑y
⊢ y ≠ 0

tactic: refine' NNReal.exists_mem_Ico_zpow _ (one_lt_coe_iff.1 hy)
state_before: α : Type ?u.460337
β : Type ?u.460340
a b c d : ℝ≥0∞
r p q x : ℝ≥0
hx : ↑x ≠ 0
y : ℝ≥0
hy : 1 < ↑y
A : y ≠ 0
⊢ ∃ n, y ^ n ≤ x ∧ x < y ^ (n + 1)

tactic: simpa only [Ne.def, coe_eq_zero] using hx
state_before: α : Type ?u.460337
β : Type ?u.460340
a b c d : ℝ≥0∞
r p q x : ℝ≥0
hx : ↑x ≠ 0
y : ℝ≥0
hy : 1 < ↑y
A : y ≠ 0
⊢ x ≠ 0

tactic: rwa [← ENNReal.coe_zpow A, ENNReal.coe_le_coe]
state_before: case intro.intro.intro.intro.refine'_1
α : Type ?u.460337
β : Type ?u.460340
a b c d : ℝ≥0∞
r p q x : ℝ≥0
hx : ↑x ≠ 0
y : ℝ≥0
hy : 1 < ↑y
A : y ≠ 0
n : ℤ
hn : y ^ n ≤ x
h'n : x < y ^ (n + 1)
⊢ ↑y ^ n ≤ ↑x

tactic: rwa [← ENNReal.coe_zpow A, ENNReal.coe_lt_coe]
state_before: case intro.intro.intro.intro.refine'_2
α : Type ?u.460337
β : Type ?u.460340
a b c d : ℝ≥0∞
r p q x : ℝ≥0
hx : ↑x ≠ 0
y : ℝ≥0
hy : 1 < ↑y
A : y ≠ 0
n : ℤ
hn : y ^ n ≤ x
h'n : x < y ^ (n + 1)
⊢ ↑x < ↑y ^ (n + 1)
Theorem: AddEquiv.toNatLinearEquiv_toAddEquiv
File: Mathlib/Algebra/Module/Equiv.lean

tactic: ext
state_before: R : Type ?u.382607
R₁ : Type ?u.382610
R₂ : Type ?u.382613
R₃ : Type ?u.382616
k : Type ?u.382619
S : Type ?u.382622
M : Type u_1
M₁ : Type ?u.382628
M₂ : Type u_2
M₃ : Type ?u.382634
N₁ : Type ?u.382637
N₂ : Type ?u.382640
N₃ : Type ?u.382643
N₄ : Type ?u.382646
ι : Type ?u.382649
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : AddCommMonoid M₂
inst✝² : AddCommMonoid M₃
inst✝¹ : Module R M
inst✝ : Module R M₂
e : M ≃+ M₂
⊢ ↑(toNatLinearEquiv e) = e

tactic: rfl
state_before: case h
R : Type ?u.382607
R₁ : Type ?u.382610
R₂ : Type ?u.382613
R₃ : Type ?u.382616
k : Type ?u.382619
S : Type ?u.382622
M : Type u_1
M₁ : Type ?u.382628
M₂ : Type u_2
M₃ : Type ?u.382634
N₁ : Type ?u.382637
N₂ : Type ?u.382640
N₃ : Type ?u.382643
N₄ : Type ?u.382646
ι : Type ?u.382649
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : AddCommMonoid M₂
inst✝² : AddCommMonoid M₃
inst✝¹ : Module R M
inst✝ : Module R M₂
e : M ≃+ M₂
x✝ : M
⊢ ↑↑(toNatLinearEquiv e) x✝ = ↑e x✝
Theorem: Relation.ReflGen.mono
File: Mathlib/Logic/Relation.lean

tactic: rfl
state_before: α : Type u_1
β : Type ?u.15799
γ : Type ?u.15802
δ : Type ?u.15805
r : α → α → Prop
a✝ b c d : α
p : α → α → Prop
hp : ∀ (a b : α), r a b → p a b
a : α
⊢ ReflGen p a a
Theorem: CategoryTheory.GrothendieckTopology.imagePresheaf_id
File: Mathlib/CategoryTheory/Sites/Subsheaf.lean

tactic: ext
state_before: C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
⊢ imagePresheaf (𝟙 F) = ⊤

tactic: simp
state_before: case obj.h.h
C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
x✝¹ : Cᵒᵖ
x✝ : F.obj x✝¹
⊢ x✝ ∈ Subpresheaf.obj (imagePresheaf (𝟙 F)) x✝¹ ↔ x✝ ∈ Subpresheaf.obj ⊤ x✝¹
Theorem: Filter.disjoint_comap
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [disjoint_iff, ← comap_inf, h.eq_bot, comap_bot]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.253431
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
h : Disjoint g₁ g₂
⊢ Disjoint (comap m g₁) (comap m g₂)
Theorem: MeasureTheory.le_iInf₂_lintegral
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: convert(monotone_lintegral μ).map_iInf₂_le f with a
state_before: α : Type u_3
β : Type ?u.284610
γ : Type ?u.284613
δ : Type ?u.284616
m : MeasurableSpace α
μ ν : Measure α
ι : Sort u_1
ι' : ι → Sort u_2
f : (i : ι) → ι' i → α → ℝ≥0∞
⊢ (∫⁻ (a : α), ⨅ (i : ι) (h : ι' i), f i h a ∂μ) ≤ ⨅ (i : ι) (h : ι' i), ∫⁻ (a : α), f i h a ∂μ

tactic: simp only [iInf_apply]
state_before: case h.e'_3.h.e'_4.h
α : Type u_3
β : Type ?u.284610
γ : Type ?u.284613
δ : Type ?u.284616
m : MeasurableSpace α
μ ν : Measure α
ι : Sort u_1
ι' : ι → Sort u_2
f : (i : ι) → ι' i → α → ℝ≥0∞
a : α
⊢ (⨅ (i : ι) (h : ι' i), f i h a) = iInf (fun i => ⨅ (j : ι' i), f i j) a
Theorem: Complex.circleTransformDeriv_eq
File: Mathlib/MeasureTheory/Integral/CircleTransform.lean

tactic: ext
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R : ℝ
z w : ℂ
f : ℂ → E
⊢ circleTransformDeriv R z w f = fun θ => (circleMap z R θ - w)⁻¹ • circleTransform R z w f θ

tactic: simp_rw [circleTransformDeriv, circleTransform, ← mul_smul, ← mul_assoc]
state_before: case h
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R : ℝ
z w : ℂ
f : ℂ → E
x✝ : ℝ
⊢ circleTransformDeriv R z w f x✝ = (circleMap z R x✝ - w)⁻¹ • circleTransform R z w f x✝

tactic: ring_nf
state_before: case h
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R : ℝ
z w : ℂ
f : ℂ → E
x✝ : ℝ
⊢ ((2 * ↑π * I)⁻¹ * deriv (circleMap z R) x✝ * ((circleMap z R x✝ - w) ^ 2)⁻¹) • f (circleMap z R x✝) =
    ((circleMap z R x✝ - w)⁻¹ * (2 * ↑π * I)⁻¹ * deriv (circleMap z R) x✝ * (circleMap z R x✝ - w)⁻¹) •
      f (circleMap z R x✝)

tactic: rw [inv_pow]
state_before: case h
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R : ℝ
z w : ℂ
f : ℂ → E
x✝ : ℝ
⊢ ((↑π)⁻¹ * I⁻¹ * deriv (circleMap z R) x✝ * (-(circleMap z R x✝ * w * 2) + circleMap z R x✝ ^ 2 + w ^ 2)⁻¹ *
        (↑(Int.ofNat 1) / ↑2)) •
      f (circleMap z R x✝) =
    ((↑π)⁻¹ * I⁻¹ * deriv (circleMap z R) x✝ * (circleMap z R x✝ - w)⁻¹ ^ 2 * (↑(Int.ofNat 1) / ↑2)) •
      f (circleMap z R x✝)

tactic: congr
state_before: case h
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R : ℝ
z w : ℂ
f : ℂ → E
x✝ : ℝ
⊢ ((↑π)⁻¹ * I⁻¹ * deriv (circleMap z R) x✝ * (-(circleMap z R x✝ * w * 2) + circleMap z R x✝ ^ 2 + w ^ 2)⁻¹ *
        (↑(Int.ofNat 1) / ↑2)) •
      f (circleMap z R x✝) =
    ((↑π)⁻¹ * I⁻¹ * deriv (circleMap z R) x✝ * ((circleMap z R x✝ - w) ^ 2)⁻¹ * (↑(Int.ofNat 1) / ↑2)) •
      f (circleMap z R x✝)

tactic: ring
state_before: case h.e_a.e_a.e_a.e_a
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R : ℝ
z w : ℂ
f : ℂ → E
x✝ : ℝ
⊢ -(circleMap z R x✝ * w * 2) + circleMap z R x✝ ^ 2 + w ^ 2 = (circleMap z R x✝ - w) ^ 2
Theorem: CategoryTheory.Limits.imageSubobject_zero_arrow
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: rw [← imageSubobject_arrow]
state_before: C : Type u
inst✝³ : Category C
X Y Z : C
f : X ⟶ Y
inst✝² : HasImage f
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
⊢ arrow (imageSubobject 0) = 0

tactic: simp
state_before: C : Type u
inst✝³ : Category C
X Y Z : C
f : X ⟶ Y
inst✝² : HasImage f
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
⊢ (imageSubobjectIso 0).hom ≫ image.ι 0 = 0
Theorem: heq_const_of_unique
File: Mathlib/Logic/Unique.lean

tactic: rw [Subsingleton.elim i default]
state_before: α : Sort u_1
inst✝ : Unique α
β : α → Sort v
f : (a : α) → β a
i x✝¹ : α
x✝ : HEq i x✝¹
⊢ HEq (f i) (Function.const α (f default) x✝¹)

tactic: rfl
state_before: α : Sort u_1
inst✝ : Unique α
β : α → Sort v
f : (a : α) → β a
i x✝¹ : α
x✝ : HEq i x✝¹
⊢ HEq (f default) (Function.const α (f default) x✝¹)
Theorem: ZFSet.eq_empty_or_nonempty
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: rw [eq_empty, ← not_exists]
state_before: u : ZFSet
⊢ u = ∅ ∨ ZFSet.Nonempty u

tactic: apply em'
state_before: u : ZFSet
⊢ (¬∃ x, x ∈ u) ∨ ZFSet.Nonempty u
Theorem: Ordnode.any_iff_exists
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rintro ⟨⟩
state_before: α : Type u_1
P : α → Prop
⊢ Any P nil → ∃ x, Emem x nil ∧ P x

tactic: rintro ⟨_, ⟨⟩, _⟩
state_before: α : Type u_1
P : α → Prop
⊢ (∃ x, Emem x nil ∧ P x) → Any P nil

tactic: simp only [Emem]
state_before: α : Type u_1
P : α → Prop
size✝ : ℕ
l : Ordnode α
x : α
r : Ordnode α
⊢ Any P (node size✝ l x r) ↔ ∃ x_1, Emem x_1 (node size✝ l x r) ∧ P x_1

tactic: simp [Any, any_iff_exists, or_and_right, exists_or]
state_before: α : Type u_1
P : α → Prop
size✝ : ℕ
l : Ordnode α
x : α
r : Ordnode α
⊢ Any P (node size✝ l x r) ↔ ∃ x_1, Any (Eq x_1) (node size✝ l x r) ∧ P x_1
Theorem: Subgroup.prod_le_iff
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simpa only [← Subgroup.toSubmonoid_le] using Submonoid.prod_le_iff
state_before: G : Type u_1
G' : Type ?u.306276
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.306285
inst✝² : AddGroup A
H✝ K✝ : Subgroup G
k : Set G
N : Type u_2
inst✝¹ : Group N
P : Type ?u.306312
inst✝ : Group P
H : Subgroup G
K : Subgroup N
J : Subgroup (G × N)
⊢ prod H K ≤ J ↔ map (MonoidHom.inl G N) H ≤ J ∧ map (MonoidHom.inr G N) K ≤ J
Theorem: CategoryTheory.Endofunctor.Algebra.Initial.right_inv
File: Mathlib/CategoryTheory/Endofunctor/Algebra.lean

tactic: rw [strInv, ← (h.to ⟨F.obj A.1, F.map A.str⟩).h, ← F.map_id, ← F.map_comp]
state_before: C : Type u
inst✝ : Category C
F : C ⥤ C
A A₀ A₁ A₂ : Algebra F
f : A₀ ⟶ A₁
g : A₁ ⟶ A₂
h : Limits.IsInitial A
⊢ A.str ≫ strInv h = 𝟙 (F.obj A.a)

tactic: congr
state_before: C : Type u
inst✝ : Category C
F : C ⥤ C
A A₀ A₁ A₂ : Algebra F
f : A₀ ⟶ A₁
g : A₁ ⟶ A₂
h : Limits.IsInitial A
⊢ F.map ((Limits.IsInitial.to h { a := F.obj A.a, str := F.map A.str }).f ≫ A.str) = F.map (𝟙 A.a)

tactic: exact left_inv h
state_before: case e_a
C : Type u
inst✝ : Category C
F : C ⥤ C
A A₀ A₁ A₂ : Algebra F
f : A₀ ⟶ A₁
g : A₁ ⟶ A₂
h : Limits.IsInitial A
⊢ (Limits.IsInitial.to h { a := F.obj A.a, str := F.map A.str }).f ≫ A.str = 𝟙 A.a
Theorem: OrderMonoidHom.cancel_left
File: Mathlib/Algebra/Order/Hom/Monoid.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type ?u.91970
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.91982
inst✝⁷ : Preorder α
inst✝⁶ : Preorder β
inst✝⁵ : Preorder γ
inst✝⁴ : Preorder δ
inst✝³ : MulOneClass α
inst✝² : MulOneClass β
inst✝¹ : MulOneClass γ
inst✝ : MulOneClass δ
f g✝ : α →*o β
g : β →*o γ
f₁ f₂ : α →*o β
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: JoinedIn.mem
File: Mathlib/Topology/PathConnected.lean

tactic: rcases h with ⟨γ, γ_in⟩
state_before: X : Type u_1
Y : Type ?u.547721
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.547736
F : Set X
h : JoinedIn F x y
⊢ x ∈ F ∧ y ∈ F

tactic: have : γ 0 ∈ F ∧ γ 1 ∈ F := by constructor <;> apply γ_in
state_before: case intro
X : Type u_1
Y : Type ?u.547721
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.547736
F : Set X
γ : Path x y
γ_in : ∀ (t : ↑I), ↑γ t ∈ F
⊢ x ∈ F ∧ y ∈ F

tactic: simpa using this
state_before: case intro
X : Type u_1
Y : Type ?u.547721
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.547736
F : Set X
γ : Path x y
γ_in : ∀ (t : ↑I), ↑γ t ∈ F
this : ↑γ 0 ∈ F ∧ ↑γ 1 ∈ F
⊢ x ∈ F ∧ y ∈ F

tactic: constructor <;> apply γ_in
state_before: X : Type u_1
Y : Type ?u.547721
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.547736
F : Set X
γ : Path x y
γ_in : ∀ (t : ↑I), ↑γ t ∈ F
⊢ ↑γ 0 ∈ F ∧ ↑γ 1 ∈ F
Theorem: LinearMap.det_zero''
File: Mathlib/LinearAlgebra/FreeModule/Determinant.lean

tactic: letI : Nonempty (Module.Free.ChooseBasisIndex R M) := (Module.Free.chooseBasis R M).index_nonempty
state_before: R : Type u_1
M : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Module.Free R M
inst✝¹ : Module.Finite R M
inst✝ : Nontrivial M
⊢ ↑LinearMap.det 0 = 0

tactic: nontriviality R
state_before: R : Type u_1
M : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Module.Free R M
inst✝¹ : Module.Finite R M
inst✝ : Nontrivial M
this : Nonempty (Module.Free.ChooseBasisIndex R M) := Basis.index_nonempty (Module.Free.chooseBasis R M)
⊢ ↑LinearMap.det 0 = 0

tactic: exact LinearMap.det_zero' (Module.Free.chooseBasis R M)
state_before: R : Type u_1
M : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Module.Free R M
inst✝¹ : Module.Finite R M
inst✝ : Nontrivial M
this : Nonempty (Module.Free.ChooseBasisIndex R M) := Basis.index_nonempty (Module.Free.chooseBasis R M)
✝ : Nontrivial R
⊢ ↑LinearMap.det 0 = 0
Theorem: MulEquiv.uniqueFactorizationMonoid
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: rw [UniqueFactorizationMonoid.iff_exists_prime_factors] at hα⊢
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : CancelCommMonoidWithZero β
e : α ≃* β
hα : UniqueFactorizationMonoid α
⊢ UniqueFactorizationMonoid β

tactic: intro a ha
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : CancelCommMonoidWithZero β
e : α ≃* β
hα : ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a
⊢ ∀ (a : β), a ≠ 0 → ∃ f, (∀ (b : β), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a

tactic: obtain ⟨w, hp, u, h⟩ :=
  hα (e.symm a) fun h =>
    ha <| by
      convert← map_zero e
      simp [← h]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : CancelCommMonoidWithZero β
e : α ≃* β
hα : ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a
a : β
ha : a ≠ 0
⊢ ∃ f, (∀ (b : β), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a

tactic: exact
  ⟨w.map e, fun b hb =>
      let ⟨c, hc, he⟩ := Multiset.mem_map.1 hb
      he ▸ e.prime_iff.1 (hp c hc),
      Units.map e.toMonoidHom u,
    by
      erw [Multiset.prod_hom, ← e.map_mul, h]
      simp⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : CancelCommMonoidWithZero β
e : α ≃* β
hα : ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a
a : β
ha : a ≠ 0
w : Multiset α
hp : ∀ (b : α), b ∈ w → Prime b
u : αˣ
h : Multiset.prod w * ↑u = ↑(symm e) a
⊢ ∃ f, (∀ (b : β), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a

tactic: convert← map_zero e
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : CancelCommMonoidWithZero β
e : α ≃* β
hα : ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a
a : β
ha : a ≠ 0
h : ↑(symm e) a = 0
⊢ a = 0

tactic: simp [← h]
state_before: case h.e'_2
α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : CancelCommMonoidWithZero β
e : α ≃* β
hα : ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a
a : β
ha : a ≠ 0
h : ↑(symm e) a = 0
⊢ ↑e 0 = a

tactic: erw [Multiset.prod_hom, ← e.map_mul, h]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : CancelCommMonoidWithZero β
e : α ≃* β
hα : ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a
a : β
ha : a ≠ 0
w : Multiset α
hp : ∀ (b : α), b ∈ w → Prime b
u : αˣ
h : Multiset.prod w * ↑u = ↑(symm e) a
⊢ Multiset.prod (Multiset.map (↑e) w) * ↑(↑(Units.map (toMonoidHom e)) u) = a

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : CancelCommMonoidWithZero β
e : α ≃* β
hα : ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a
a : β
ha : a ≠ 0
w : Multiset α
hp : ∀ (b : α), b ∈ w → Prime b
u : αˣ
h : Multiset.prod w * ↑u = ↑(symm e) a
⊢ ↑e (↑(symm e) a) = a
Theorem: Asymptotics.superpolynomialDecay_mul_param_pow_iff
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

tactic: simpa [mul_comm f] using superpolynomialDecay_param_pow_mul_iff f hk n
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedField β
inst✝ : OrderTopology β
hk : Tendsto k l atTop
n : ℕ
⊢ SuperpolynomialDecay l k (f * k ^ n) ↔ SuperpolynomialDecay l k f
Theorem: Turing.reaches_eval
File: Mathlib/Computability/TuringMachine.lean

tactic: refine' Part.ext fun _ ↦ ⟨fun h ↦ _, fun h ↦ _⟩
state_before: σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
⊢ eval f a = eval f b

tactic: have ⟨ac, c0⟩ := mem_eval.1 h
state_before: case refine'_1
σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
x✝ : σ
h : x✝ ∈ eval f a
⊢ x✝ ∈ eval f b

tactic: exact mem_eval.2 ⟨(or_iff_left_of_imp fun cb ↦ (eval_maximal h).1 cb ▸ ReflTransGen.refl).1
  (reaches_total ab ac), c0⟩
state_before: case refine'_1
σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
x✝ : σ
h : x✝ ∈ eval f a
ac : Reaches f a x✝
c0 : f x✝ = none
⊢ x✝ ∈ eval f b

tactic: have ⟨bc, c0⟩ := mem_eval.1 h
state_before: case refine'_2
σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
x✝ : σ
h : x✝ ∈ eval f b
⊢ x✝ ∈ eval f a

tactic: exact mem_eval.2 ⟨ab.trans bc, c0⟩
state_before: case refine'_2
σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
x✝ : σ
h : x✝ ∈ eval f b
bc : Reaches f b x✝
c0 : f x✝ = none
⊢ x✝ ∈ eval f a