1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.hasPDF_of_pdf_ne_zero
File: Mathlib/Probability/Density.lean

tactic: refine ⟨?_, ?_, hac⟩
state_before: Ω : Type u_1
E : Type u_2
inst✝ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
X : Ω → E
hac : map X ℙ ≪ μ
hpdf : ¬pdf X ℙ μ =ᶠ[ae μ] 0
⊢ HasPDF X ℙ μ
state_after: case refine_1
Ω : Type u_1
E : Type u_2
inst✝ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
X : Ω → E
hac : map X ℙ ≪ μ
hpdf : ¬pdf X ℙ μ =ᶠ[ae μ] 0
⊢ AEMeasurable X ℙ

case refine_2
Ω : Type u_1
E : Type u_2
inst✝ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
X : Ω → E
hac : map X ℙ ≪ μ
hpdf : ¬pdf X ℙ μ =ᶠ[ae μ] 0
⊢ (map X ℙ).HaveLebesgueDecomposition μ

tactic: exact aemeasurable_of_pdf_ne_zero X hpdf
state_before: case refine_1
Ω : Type u_1
E : Type u_2
inst✝ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
X : Ω → E
hac : map X ℙ ≪ μ
hpdf : ¬pdf X ℙ μ =ᶠ[ae μ] 0
⊢ AEMeasurable X ℙ
state_after: no goals

tactic: contrapose! hpdf
state_before: case refine_2
Ω : Type u_1
E : Type u_2
inst✝ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
X : Ω → E
hac : map X ℙ ≪ μ
hpdf : ¬pdf X ℙ μ =ᶠ[ae μ] 0
⊢ (map X ℙ).HaveLebesgueDecomposition μ
state_after: case refine_2
Ω : Type u_1
E : Type u_2
inst✝ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
X : Ω → E
hac : map X ℙ ≪ μ
hpdf : ¬(map X ℙ).HaveLebesgueDecomposition μ
⊢ pdf X ℙ μ =ᶠ[ae μ] 0

tactic: have := pdf_of_not_haveLebesgueDecomposition hpdf
state_before: case refine_2
Ω : Type u_1
E : Type u_2
inst✝ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
X : Ω → E
hac : map X ℙ ≪ μ
hpdf : ¬(map X ℙ).HaveLebesgueDecomposition μ
⊢ pdf X ℙ μ =ᶠ[ae μ] 0
state_after: case refine_2
Ω : Type u_1
E : Type u_2
inst✝ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
X : Ω → E
hac : map X ℙ ≪ μ
hpdf : ¬(map X ℙ).HaveLebesgueDecomposition μ
this : pdf X ℙ μ = 0
⊢ pdf X ℙ μ =ᶠ[ae μ] 0

tactic: filter_upwards using congrFun this
state_before: case refine_2
Ω : Type u_1
E : Type u_2
inst✝ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
X : Ω → E
hac : map X ℙ ≪ μ
hpdf : ¬(map X ℙ).HaveLebesgueDecomposition μ
this : pdf X ℙ μ = 0
⊢ pdf X ℙ μ =ᶠ[ae μ] 0
state_after: no goals
Theorem: Function.bijOn_ptsOfPeriod
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: rw [← comp_apply (f := f), comp_iterate_pred_of_pos f hn, hx.eq]
state_before: α : Type u_1
β : Type u_2
f✝ fa : α → α
fb : β → β
x✝ y : α
m n✝ : ℕ
f : α → α
n : ℕ
hn : 0 < n
x : α
hx : x ∈ ptsOfPeriod f n
⊢ f (f^[n.pred] x) = x
state_after: no goals
Theorem: Matrix.zpow_add_of_nonpos
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: rcases nonsing_inv_cancel_or_zero A with (⟨h, _⟩ | h)
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
m n : ℤ
hm : m ≤ 0
hn : n ≤ 0
⊢ A ^ (m + n) = A ^ m * A ^ n
state_after: case inl.intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
m n : ℤ
hm : m ≤ 0
hn : n ≤ 0
h : A⁻¹ * A = 1
right✝ : A * A⁻¹ = 1
⊢ A ^ (m + n) = A ^ m * A ^ n

case inr
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
m n : ℤ
hm : m ≤ 0
hn : n ≤ 0
h : A⁻¹ = 0
⊢ A ^ (m + n) = A ^ m * A ^ n

tactic: exact zpow_add (isUnit_det_of_left_inverse h) m n
state_before: case inl.intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
m n : ℤ
hm : m ≤ 0
hn : n ≤ 0
h : A⁻¹ * A = 1
right✝ : A * A⁻¹ = 1
⊢ A ^ (m + n) = A ^ m * A ^ n
state_after: no goals

tactic: obtain ⟨k, rfl⟩ := exists_eq_neg_ofNat hm
state_before: case inr
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
m n : ℤ
hm : m ≤ 0
hn : n ≤ 0
h : A⁻¹ = 0
⊢ A ^ (m + n) = A ^ m * A ^ n
state_after: case inr.intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℤ
hn : n ≤ 0
h : A⁻¹ = 0
k : ℕ
hm : -↑k ≤ 0
⊢ A ^ (-↑k + n) = A ^ (-↑k) * A ^ n

tactic: obtain ⟨l, rfl⟩ := exists_eq_neg_ofNat hn
state_before: case inr.intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℤ
hn : n ≤ 0
h : A⁻¹ = 0
k : ℕ
hm : -↑k ≤ 0
⊢ A ^ (-↑k + n) = A ^ (-↑k) * A ^ n
state_after: case inr.intro.intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : A⁻¹ = 0
k : ℕ
hm : -↑k ≤ 0
l : ℕ
hn : -↑l ≤ 0
⊢ A ^ (-↑k + -↑l) = A ^ (-↑k) * A ^ (-↑l)

tactic: simp_rw [← neg_add, ← Int.ofNat_add, zpow_neg_natCast, ← inv_pow', h, pow_add]
state_before: case inr.intro.intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : A⁻¹ = 0
k : ℕ
hm : -↑k ≤ 0
l : ℕ
hn : -↑l ≤ 0
⊢ A ^ (-↑k + -↑l) = A ^ (-↑k) * A ^ (-↑l)
state_after: no goals
Theorem: Real.le_sin_mul
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

tactic: simpa [mul_comm x] using
  strictConcaveOn_sin_Icc.concaveOn.2 ⟨le_rfl, pi_pos.le⟩
    ⟨pi_div_two_pos.le, half_le_self pi_pos.le⟩ (sub_nonneg.2 hx') hx
state_before: x : ℝ
hx : 0 ≤ x
hx' : x ≤ 1
⊢ x ≤ sin (π / 2 * x)
state_after: no goals
Theorem: Complex.tan_mul_cos
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [tan_eq_sin_div_cos, div_mul_cancel₀ _ hx]
state_before: x✝ y x : ℂ
hx : cos x ≠ 0
⊢ tan x * cos x = sin x
state_after: no goals
Theorem: InnerProductGeometry.cos_angle_sub_mul_norm_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [← neg_eq_zero, ← inner_neg_right] at h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
⊢ Real.cos (angle x (x - y)) * ‖x - y‖ = ‖x‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, -y⟫_ℝ = 0
⊢ Real.cos (angle x (x - y)) * ‖x - y‖ = ‖x‖

tactic: rw [sub_eq_add_neg, cos_angle_add_mul_norm_of_inner_eq_zero h]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, -y⟫_ℝ = 0
⊢ Real.cos (angle x (x - y)) * ‖x - y‖ = ‖x‖
state_after: no goals
Theorem: MeasureTheory.measure_integral_le_pos
File: Mathlib/MeasureTheory/Integral/Average.lean

tactic: simpa only [average_eq_integral] using
  measure_average_le_pos (IsProbabilityMeasure.ne_zero μ) hf
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ ν : Measure α
s t N : Set α
f : α → ℝ
inst✝ : IsProbabilityMeasure μ
hf : Integrable f μ
⊢ 0 < μ {x | ∫ (a : α), f a ∂μ ≤ f x}
state_after: no goals
Theorem: MeasureTheory.ofReal_toReal_ae_eq
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: filter_upwards [hf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : ∀ᵐ (x : α) ∂μ, f x < ⊤
⊢ (fun x => ENNReal.ofReal (f x).toReal) =ᶠ[ae μ] f
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : ∀ᵐ (x : α) ∂μ, f x < ⊤
⊢ ∀ (a : α), f a < ⊤ → ENNReal.ofReal (f a).toReal = f a

tactic: intro x hx
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : ∀ᵐ (x : α) ∂μ, f x < ⊤
⊢ ∀ (a : α), f a < ⊤ → ENNReal.ofReal (f a).toReal = f a
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : ∀ᵐ (x : α) ∂μ, f x < ⊤
x : α
hx : f x < ⊤
⊢ ENNReal.ofReal (f x).toReal = f x

tactic: simp only [hx.ne, ofReal_toReal, Ne, not_false_iff]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : ∀ᵐ (x : α) ∂μ, f x < ⊤
x : α
hx : f x < ⊤
⊢ ENNReal.ofReal (f x).toReal = f x
state_after: no goals
Theorem: NormedAddCommGroup.tendsto_atTop'
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simp [dist_eq_norm]
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : NoMaxOrder α
β : Type u_5
inst✝ : SeminormedAddCommGroup β
f : α → β
b : β
⊢ (∀ (ib : ℝ), 0 < ib → ∃ ia, True ∧ ∀ x ∈ Set.Ioi ia, f x ∈ ball b ib) ↔
    ∀ (ε : ℝ), 0 < ε → ∃ N, ∀ (n : α), N < n → ‖f n - b‖ < ε
state_after: no goals
Theorem: LiouvilleWith.nat_sub_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

tactic: simp [sub_eq_add_neg]
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
⊢ LiouvilleWith p (↑n - x) ↔ LiouvilleWith p x
state_after: no goals
Theorem: List.Sorted.gt_of_ge
File: Mathlib/Data/List/Sort.lean

tactic: simp_rw [ne_comm]
state_before: α : Type u
r : α → α → Prop
a : α
l✝ : List α
inst✝ : PartialOrder α
l : List α
h₁ : Sorted (fun x x_1 => x ≥ x_1) l
h₂ : l.Nodup
⊢ Pairwise (fun x x_1 => x_1 ≠ x) l
state_after: α : Type u
r : α → α → Prop
a : α
l✝ : List α
inst✝ : PartialOrder α
l : List α
h₁ : Sorted (fun x x_1 => x ≥ x_1) l
h₂ : l.Nodup
⊢ Pairwise (fun x x_1 => x ≠ x_1) l

tactic: exact h₂
state_before: α : Type u
r : α → α → Prop
a : α
l✝ : List α
inst✝ : PartialOrder α
l : List α
h₁ : Sorted (fun x x_1 => x ≥ x_1) l
h₂ : l.Nodup
⊢ Pairwise (fun x x_1 => x ≠ x_1) l
state_after: no goals
Theorem: Ordinal.isClosed_iff_sup
File: Mathlib/SetTheory/Ordinal/Topology.lean

tactic: use fun hs ι hι f hf => (mem_closed_iff_sup hs).2 ⟨ι, hι, f, hf, rfl⟩
state_before: s : Set Ordinal.{u}
a : Ordinal.{u}
⊢ IsClosed s ↔ ∀ {ι : Type u}, Nonempty ι → ∀ (f : ι → Ordinal.{u}), (∀ (i : ι), f i ∈ s) → sup f ∈ s
state_after: case mpr
s : Set Ordinal.{u}
a : Ordinal.{u}
⊢ (∀ {ι : Type u}, Nonempty ι → ∀ (f : ι → Ordinal.{u}), (∀ (i : ι), f i ∈ s) → sup f ∈ s) → IsClosed s

tactic: rw [← closure_subset_iff_isClosed]
state_before: case mpr
s : Set Ordinal.{u}
a : Ordinal.{u}
⊢ (∀ {ι : Type u}, Nonempty ι → ∀ (f : ι → Ordinal.{u}), (∀ (i : ι), f i ∈ s) → sup f ∈ s) → IsClosed s
state_after: case mpr
s : Set Ordinal.{u}
a : Ordinal.{u}
⊢ (∀ {ι : Type u}, Nonempty ι → ∀ (f : ι → Ordinal.{u}), (∀ (i : ι), f i ∈ s) → sup f ∈ s) → closure s ⊆ s

tactic: intro h x hx
state_before: case mpr
s : Set Ordinal.{u}
a : Ordinal.{u}
⊢ (∀ {ι : Type u}, Nonempty ι → ∀ (f : ι → Ordinal.{u}), (∀ (i : ι), f i ∈ s) → sup f ∈ s) → closure s ⊆ s
state_after: case mpr
s : Set Ordinal.{u}
a : Ordinal.{u}
h : ∀ {ι : Type u}, Nonempty ι → ∀ (f : ι → Ordinal.{u}), (∀ (i : ι), f i ∈ s) → sup f ∈ s
x : Ordinal.{u}
hx : x ∈ closure s
⊢ x ∈ s

tactic: rcases mem_closure_iff_sup.1 hx with ⟨ι, hι, f, hf, rfl⟩
state_before: case mpr
s : Set Ordinal.{u}
a : Ordinal.{u}
h : ∀ {ι : Type u}, Nonempty ι → ∀ (f : ι → Ordinal.{u}), (∀ (i : ι), f i ∈ s) → sup f ∈ s
x : Ordinal.{u}
hx : x ∈ closure s
⊢ x ∈ s
state_after: case mpr.intro.intro.intro.intro
s : Set Ordinal.{u}
a : Ordinal.{u}
h : ∀ {ι : Type u}, Nonempty ι → ∀ (f : ι → Ordinal.{u}), (∀ (i : ι), f i ∈ s) → sup f ∈ s
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
hx : sup f ∈ closure s
⊢ sup f ∈ s

tactic: exact h hι f hf
state_before: case mpr.intro.intro.intro.intro
s : Set Ordinal.{u}
a : Ordinal.{u}
h : ∀ {ι : Type u}, Nonempty ι → ∀ (f : ι → Ordinal.{u}), (∀ (i : ι), f i ∈ s) → sup f ∈ s
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
hx : sup f ∈ closure s
⊢ sup f ∈ s
state_after: no goals
Theorem: Matrix.mul_assoc
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalSemiring α
inst✝¹ : Fintype m
inst✝ : Fintype n
L : Matrix l m α
M : Matrix m n α
N : Matrix n o α
⊢ L * M * N = L * (M * N)
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalSemiring α
inst✝¹ : Fintype m
inst✝ : Fintype n
L : Matrix l m α
M : Matrix m n α
N : Matrix n o α
i✝ : l
j✝ : o
⊢ (L * M * N) i✝ j✝ = (L * (M * N)) i✝ j✝

tactic: apply dotProduct_assoc
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalSemiring α
inst✝¹ : Fintype m
inst✝ : Fintype n
L : Matrix l m α
M : Matrix m n α
N : Matrix n o α
i✝ : l
j✝ : o
⊢ (L * M * N) i✝ j✝ = (L * (M * N)) i✝ j✝
state_after: no goals
Theorem: Lagrange.eval_interpolate_not_at_node'
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [← div_one (eval x (interpolate s v r)), ← @eval_one _ _ x, ← interpolate_one hvs hs,
  eval_interpolate_not_at_node r hx, eval_interpolate_not_at_node 1 hx]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v r : ι → F
i : ι
x : F
hvs : Set.InjOn v ↑s
hs : s.Nonempty
hx : ∀ i ∈ s, x ≠ v i
⊢ eval x ((interpolate s v) r) =
    (∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ * r i) / ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹
state_after: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v r : ι → F
i : ι
x : F
hvs : Set.InjOn v ↑s
hs : s.Nonempty
hx : ∀ i ∈ s, x ≠ v i
⊢ (eval x (nodal s v) * ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ * r i) /
      (eval x (nodal s v) * ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ * 1 i) =
    (∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ * r i) / ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹

tactic: simp only [mul_div_mul_left _ _ (eval_nodal_not_at_node hx), Pi.one_apply, mul_one]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v r : ι → F
i : ι
x : F
hvs : Set.InjOn v ↑s
hs : s.Nonempty
hx : ∀ i ∈ s, x ≠ v i
⊢ (eval x (nodal s v) * ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ * r i) /
      (eval x (nodal s v) * ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ * 1 i) =
    (∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ * r i) / ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹
state_after: no goals
Theorem: MvPolynomial.exists_restrict_to_vars
File: Mathlib/Algebra/MvPolynomial/Supported.lean

tactic: rw [← mem_supported, supported_eq_range_rename, AlgHom.mem_range] at hF
state_before: σ : Type u_1
τ : Type u_2
R✝ : Type u
S : Type v
r : R✝
e : ℕ
n m : σ
inst✝¹ : CommSemiring R✝
p q : MvPolynomial σ R✝
s t : Set σ
R : Type u_3
inst✝ : CommRing R
F : MvPolynomial σ ℤ
hF : ↑F.vars ⊆ s
⊢ ∃ f, ∀ (x : σ → R), f (x ∘ Subtype.val) = (aeval x) F
state_after: σ : Type u_1
τ : Type u_2
R✝ : Type u
S : Type v
r : R✝
e : ℕ
n m : σ
inst✝¹ : CommSemiring R✝
p q : MvPolynomial σ R✝
s t : Set σ
R : Type u_3
inst✝ : CommRing R
F : MvPolynomial σ ℤ
hF : ∃ x, (rename Subtype.val) x = F
⊢ ∃ f, ∀ (x : σ → R), f (x ∘ Subtype.val) = (aeval x) F

tactic: cases' hF with F' hF'
state_before: σ : Type u_1
τ : Type u_2
R✝ : Type u
S : Type v
r : R✝
e : ℕ
n m : σ
inst✝¹ : CommSemiring R✝
p q : MvPolynomial σ R✝
s t : Set σ
R : Type u_3
inst✝ : CommRing R
F : MvPolynomial σ ℤ
hF : ∃ x, (rename Subtype.val) x = F
⊢ ∃ f, ∀ (x : σ → R), f (x ∘ Subtype.val) = (aeval x) F
state_after: case intro
σ : Type u_1
τ : Type u_2
R✝ : Type u
S : Type v
r : R✝
e : ℕ
n m : σ
inst✝¹ : CommSemiring R✝
p q : MvPolynomial σ R✝
s t : Set σ
R : Type u_3
inst✝ : CommRing R
F : MvPolynomial σ ℤ
F' : MvPolynomial { x // x ∈ s } ℤ
hF' : (rename Subtype.val) F' = F
⊢ ∃ f, ∀ (x : σ → R), f (x ∘ Subtype.val) = (aeval x) F

tactic: use fun z ↦ aeval z F'
state_before: case intro
σ : Type u_1
τ : Type u_2
R✝ : Type u
S : Type v
r : R✝
e : ℕ
n m : σ
inst✝¹ : CommSemiring R✝
p q : MvPolynomial σ R✝
s t : Set σ
R : Type u_3
inst✝ : CommRing R
F : MvPolynomial σ ℤ
F' : MvPolynomial { x // x ∈ s } ℤ
hF' : (rename Subtype.val) F' = F
⊢ ∃ f, ∀ (x : σ → R), f (x ∘ Subtype.val) = (aeval x) F
state_after: case h
σ : Type u_1
τ : Type u_2
R✝ : Type u
S : Type v
r : R✝
e : ℕ
n m : σ
inst✝¹ : CommSemiring R✝
p q : MvPolynomial σ R✝
s t : Set σ
R : Type u_3
inst✝ : CommRing R
F : MvPolynomial σ ℤ
F' : MvPolynomial { x // x ∈ s } ℤ
hF' : (rename Subtype.val) F' = F
⊢ ∀ (x : σ → R), (aeval (x ∘ Subtype.val)) F' = (aeval x) F

tactic: intro x
state_before: case h
σ : Type u_1
τ : Type u_2
R✝ : Type u
S : Type v
r : R✝
e : ℕ
n m : σ
inst✝¹ : CommSemiring R✝
p q : MvPolynomial σ R✝
s t : Set σ
R : Type u_3
inst✝ : CommRing R
F : MvPolynomial σ ℤ
F' : MvPolynomial { x // x ∈ s } ℤ
hF' : (rename Subtype.val) F' = F
⊢ ∀ (x : σ → R), (aeval (x ∘ Subtype.val)) F' = (aeval x) F
state_after: case h
σ : Type u_1
τ : Type u_2
R✝ : Type u
S : Type v
r : R✝
e : ℕ
n m : σ
inst✝¹ : CommSemiring R✝
p q : MvPolynomial σ R✝
s t : Set σ
R : Type u_3
inst✝ : CommRing R
F : MvPolynomial σ ℤ
F' : MvPolynomial { x // x ∈ s } ℤ
hF' : (rename Subtype.val) F' = F
x : σ → R
⊢ (aeval (x ∘ Subtype.val)) F' = (aeval x) F

tactic: simp only [← hF', aeval_rename]
state_before: case h
σ : Type u_1
τ : Type u_2
R✝ : Type u
S : Type v
r : R✝
e : ℕ
n m : σ
inst✝¹ : CommSemiring R✝
p q : MvPolynomial σ R✝
s t : Set σ
R : Type u_3
inst✝ : CommRing R
F : MvPolynomial σ ℤ
F' : MvPolynomial { x // x ∈ s } ℤ
hF' : (rename Subtype.val) F' = F
x : σ → R
⊢ (aeval (x ∘ Subtype.val)) F' = (aeval x) F
state_after: no goals
Theorem: CategoryTheory.Equivalence.funInvIdAssoc_inv_app
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: dsimp [funInvIdAssoc]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
F : C ⥤ E
X : C
⊢ (e.funInvIdAssoc F).inv.app X = F.map (e.unit.app X)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
F : C ⥤ E
X : C
⊢ (𝟙 (F.obj X) ≫ F.map (e.unitIso.hom.app X)) ≫ 𝟙 (F.obj (e.inverse.obj (e.functor.obj X))) = F.map (e.unit.app X)

tactic: aesop_cat
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
F : C ⥤ E
X : C
⊢ (𝟙 (F.obj X) ≫ F.map (e.unitIso.hom.app X)) ≫ 𝟙 (F.obj (e.inverse.obj (e.functor.obj X))) = F.map (e.unit.app X)
state_after: no goals
Theorem: Rack.involutory_invAct_eq_act
File: Mathlib/Algebra/Quandle.lean

tactic: rw [← left_cancel x, right_inv, h x]
state_before: R✝ : Type u_1
inst✝¹ : Rack R✝
R : Type u_2
inst✝ : Rack R
h : IsInvolutory R
x y : R
⊢ x ◃⁻¹ y = x ◃ y
state_after: no goals
Theorem: CategoryTheory.Adjunction.natTransEquiv_id_symm
File: Mathlib/CategoryTheory/Adjunction/Unique.lean

tactic: ext
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
⊢ (adj.natTransEquiv adj).symm (𝟙 F) = 𝟙 G
state_after: case w.h
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
x✝ : D
⊢ ((adj.natTransEquiv adj).symm (𝟙 F)).app x✝ = (𝟙 G).app x✝

tactic: simp
state_before: case w.h
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
x✝ : D
⊢ ((adj.natTransEquiv adj).symm (𝟙 F)).app x✝ = (𝟙 G).app x✝
state_after: no goals
Theorem: TopCat.snd_iso_of_left_embedding_range_subset
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: let esto : (pullback f g : TopCat) ≃ₜ Y :=
  (Homeomorph.ofEmbedding _ (snd_embedding_of_left_embedding hf g)).trans
    { toFun := Subtype.val
      invFun := fun x =>
        ⟨x, by
          rw [pullback_snd_range]
          exact ⟨_, (H (Set.mem_range_self x)).choose_spec⟩⟩
      left_inv := fun ⟨_, _⟩ => rfl
      right_inv := fun x => rfl }
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
hf : Embedding ⇑f
g : Y ⟶ S
H : Set.range ⇑g ⊆ Set.range ⇑f
⊢ IsIso pullback.snd
state_after: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
hf : Embedding ⇑f
g : Y ⟶ S
H : Set.range ⇑g ⊆ Set.range ⇑f
esto : ↑(pullback f g) ≃ₜ ↑Y :=
  (Homeomorph.ofEmbedding ⇑pullback.snd ⋯).trans
    { toFun := Subtype.val, invFun := fun x => ⟨x, ⋯⟩, left_inv := ⋯, right_inv := ⋯, continuous_toFun := ⋯,
      continuous_invFun := ⋯ }
⊢ IsIso pullback.snd

tactic: convert (isoOfHomeo esto).isIso_hom
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
hf : Embedding ⇑f
g : Y ⟶ S
H : Set.range ⇑g ⊆ Set.range ⇑f
esto : ↑(pullback f g) ≃ₜ ↑Y :=
  (Homeomorph.ofEmbedding ⇑pullback.snd ⋯).trans
    { toFun := Subtype.val, invFun := fun x => ⟨x, ⋯⟩, left_inv := ⋯, right_inv := ⋯, continuous_toFun := ⋯,
      continuous_invFun := ⋯ }
⊢ IsIso pullback.snd
state_after: no goals

tactic: rw [pullback_snd_range]
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
hf : Embedding ⇑f
g : Y ⟶ S
H : Set.range ⇑g ⊆ Set.range ⇑f
x : ↑Y
⊢ x ∈ Set.range ⇑pullback.snd
state_after: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
hf : Embedding ⇑f
g : Y ⟶ S
H : Set.range ⇑g ⊆ Set.range ⇑f
x : ↑Y
⊢ x ∈ {y | ∃ x, f x = g y}

tactic: exact ⟨_, (H (Set.mem_range_self x)).choose_spec⟩
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
hf : Embedding ⇑f
g : Y ⟶ S
H : Set.range ⇑g ⊆ Set.range ⇑f
x : ↑Y
⊢ x ∈ {y | ∃ x, f x = g y}
state_after: no goals
Theorem: MeasureTheory.FiniteMeasure.restrict_nonzero_iff
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: rw [← mass_nonzero_iff, restrict_mass]
state_before: Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type u_2
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ : FiniteMeasure Ω
A : Set Ω
⊢ μ.restrict A ≠ 0 ↔ μ A ≠ 0
state_after: no goals
Theorem: Con.pow
File: Mathlib/GroupTheory/Congruence/Basic.lean

tactic: simpa using c.refl _
state_before: M✝ : Type u_1
N : Type u_2
P : Type u_3
M : Type u_4
inst✝ : Monoid M
c : Con M
w x : M
x✝ : c w x
⊢ c (w ^ 0) (x ^ 0)
state_after: no goals

tactic: simpa [pow_succ] using c.mul (Con.pow c n h) h
state_before: M✝ : Type u_1
N : Type u_2
P : Type u_3
M : Type u_4
inst✝ : Monoid M
c : Con M
n : ℕ
w x : M
h : c w x
⊢ c (w ^ n.succ) (x ^ n.succ)
state_after: no goals
Theorem: Fin.cycleRange_succAbove
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: cases' lt_or_ge (castSucc j) i with h h
state_before: n : ℕ
i : Fin (n + 1)
j : Fin n
⊢ i.cycleRange (i.succAbove j) = j.succ
state_after: case inl
n : ℕ
i : Fin (n + 1)
j : Fin n
h : j.castSucc < i
⊢ i.cycleRange (i.succAbove j) = j.succ

case inr
n : ℕ
i : Fin (n + 1)
j : Fin n
h : j.castSucc ≥ i
⊢ i.cycleRange (i.succAbove j) = j.succ

tactic: rw [Fin.succAbove_of_castSucc_lt _ _ h, Fin.cycleRange_of_lt h, Fin.coeSucc_eq_succ]
state_before: case inl
n : ℕ
i : Fin (n + 1)
j : Fin n
h : j.castSucc < i
⊢ i.cycleRange (i.succAbove j) = j.succ
state_after: no goals

tactic: rw [Fin.succAbove_of_le_castSucc _ _ h, Fin.cycleRange_of_gt (Fin.le_castSucc_iff.mp h)]
state_before: case inr
n : ℕ
i : Fin (n + 1)
j : Fin n
h : j.castSucc ≥ i
⊢ i.cycleRange (i.succAbove j) = j.succ
state_after: no goals