tasksource/leandojo huggingface dataset:
Theorem: PerfectClosure.nat_cast
File: Mathlib/FieldTheory/PerfectClosure.lean

tactic: induction' n with n ih
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n x : ℕ
⊢ ↑x = mk K p (n, ↑x)

tactic: rw [ih]
state_before: case succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x n : ℕ
ih : ↑x = mk K p (n, ↑x)
⊢ ↑x = mk K p (Nat.succ n, ↑x)

tactic: apply Quot.sound
state_before: case succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x n : ℕ
ih : ↑x = mk K p (n, ↑x)
⊢ mk K p (n, ↑x) = mk K p (Nat.succ n, ↑x)

tactic: suffices R K p (n, (x : K)) (Nat.succ n, frobenius K p (x : K)) by
  rwa [frobenius_nat_cast K p x] at this
state_before: case succ.a
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x n : ℕ
ih : ↑x = mk K p (n, ↑x)
⊢ R K p (n, ↑x) (Nat.succ n, ↑x)

tactic: apply R.intro
state_before: case succ.a
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x n : ℕ
ih : ↑x = mk K p (n, ↑x)
⊢ R K p (n, ↑x) (Nat.succ n, ↑(frobenius K p) ↑x)

tactic: induction' x with x ih
state_before: case zero
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x : ℕ
⊢ ↑x = mk K p (Nat.zero, ↑x)

tactic: rw [Nat.cast_succ, Nat.cast_succ, ih]
state_before: case zero.succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x : ℕ
ih : ↑x = mk K p (Nat.zero, ↑x)
⊢ ↑(Nat.succ x) = mk K p (Nat.zero, ↑(Nat.succ x))

tactic: rfl
state_before: case zero.succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x : ℕ
ih : ↑x = mk K p (Nat.zero, ↑x)
⊢ mk K p (Nat.zero, ↑x) + 1 = mk K p (Nat.zero, ↑x + 1)

tactic: simp
state_before: case zero.zero
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
⊢ ↑Nat.zero = mk K p (Nat.zero, ↑Nat.zero)

tactic: rwa [frobenius_nat_cast K p x] at this
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x n : ℕ
ih : ↑x = mk K p (n, ↑x)
this : R K p (n, ↑x) (Nat.succ n, ↑(frobenius K p) ↑x)
⊢ R K p (n, ↑x) (Nat.succ n, ↑x)
Theorem: Polynomial.divByMonic_zero
File: Mathlib/Data/Polynomial/Div.lean

tactic: haveI := monic_zero_iff_subsingleton.mp h
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
h : Monic 0
⊢ p /ₘ 0 = 0

tactic: simp
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
h : Monic 0
this : Subsingleton R
⊢ p /ₘ 0 = 0

tactic: unfold divByMonic divModByMonicAux
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
h : ¬Monic 0
⊢ p /ₘ 0 = 0

tactic: rw [dif_neg h]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
h : ¬Monic 0
⊢ (if h : Monic 0 then
      (if h_1 : degree 0 ≤ degree p ∧ p ≠ 0 then
          let z := ↑C (leadingCoeff p) * X ^ (natDegree p - natDegree 0);
          let_fun _wf := (_ : degree (p - ↑C (leadingCoeff p) * X ^ (natDegree p - natDegree 0) * 0) < degree p);
          let dm := divModByMonicAux (p - z * 0) (_ : Monic 0);
          (z + dm.fst, dm.snd)
        else (0, p)).fst
    else 0) =
    0
Theorem: List.nil_eq_rotate_iff
File: Mathlib/Data/List/Rotate.lean

tactic: rw [eq_comm, rotate_eq_nil_iff, eq_comm]
state_before: α : Type u
l : List α
n : ℕ
⊢ [] = rotate l n ↔ [] = l
Theorem: CharP.char_ne_one
File: Mathlib/Algebra/CharP/Basic.lean

tactic: simpa using (cast_eq_zero_iff R p 1).mpr (hp ▸ dvd_refl p)
state_before: R : Type u_1
inst✝¹ : NonAssocSemiring R
inst✝ : Nontrivial R
p : ℕ
hc : CharP R p
hp : p = 1
⊢ 1 = 0
Theorem: Polynomial.cyclotomic_prime_pow_mul_X_pow_sub_one
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: rw [cyclotomic_prime_pow_eq_geom_sum hn.out, geom_sum_mul, ← pow_mul, pow_succ, mul_comm]
state_before: R : Type u_1
inst✝ : CommRing R
p k : ℕ
hn : Fact (Nat.Prime p)
⊢ cyclotomic (p ^ (k + 1)) R * (X ^ p ^ k - 1) = X ^ p ^ (k + 1) - 1
Theorem: List.Perm.erase
File: Mathlib/Data/List/Perm.lean

tactic: have h₂ : a ∉ l₂ := mt p.mem_iff.2 h₁
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
h₁ : ¬a ∈ l₁
⊢ List.erase l₁ a ~ List.erase l₂ a

tactic: rw [erase_of_not_mem h₁, erase_of_not_mem h₂]
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
h₁ : ¬a ∈ l₁
h₂ : ¬a ∈ l₂
⊢ List.erase l₁ a ~ List.erase l₂ a

tactic: exact p
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
h₁ : ¬a ∈ l₁
h₂ : ¬a ∈ l₂
⊢ l₁ ~ l₂
Theorem: Finset.eq_univ_iff_forall
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp [ext_iff]
state_before: α : Type u_1
β : Type ?u.324
γ : Type ?u.327
inst✝ : Fintype α
s t : Finset α
⊢ s = univ ↔ ∀ (x : α), x ∈ s
Theorem: EuclideanGeometry.dist_center_eq_dist_center_of_mem_sphere'
File: Mathlib/Geometry/Euclidean/Sphere/Basic.lean

tactic: rw [mem_sphere'.1 hp₁, mem_sphere'.1 hp₂]
state_before: V : Type ?u.5447
P : Type u_1
inst✝ : MetricSpace P
p₁ p₂ : P
s : Sphere P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
⊢ dist s.center p₁ = dist s.center p₂
Theorem: MeasureTheory.measure_eq_iInf'
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: simp_rw [iInf_subtype, iInf_and, Subtype.coe_mk, ← measure_eq_iInf]
state_before: α : Type u_1
β : Type ?u.10941
γ : Type ?u.10944
δ : Type ?u.10947
ι : Type ?u.10950
inst✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
μ : Measure α
s : Set α
⊢ ↑↑μ s = ⨅ (t : { t // s ⊆ t ∧ MeasurableSet t }), ↑↑μ ↑t
Theorem: CauchySeq.prod_map
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: simpa only [CauchySeq, prod_map_map_eq', prod_atTop_atTop_eq] using hu.prod hv
state_before: α : Type u
β : Type v
inst✝³ : UniformSpace α
γ : Type u_1
δ : Type u_2
inst✝² : UniformSpace β
inst✝¹ : SemilatticeSup γ
inst✝ : SemilatticeSup δ
u : γ → α
v : δ → β
hu : CauchySeq u
hv : CauchySeq v
⊢ CauchySeq (Prod.map u v)
Theorem: UpperSet.compl_iSup
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp only [coe_compl, coe_iSup, compl_iInter, LowerSet.coe_iSup]
state_before: α : Type u_1
β : Type ?u.84048
γ : Type ?u.84051
ι : Sort u_2
κ : ι → Sort ?u.84059
inst✝ : LE α
s t : UpperSet α
a : α
f : ι → UpperSet α
⊢ ↑(compl (⨆ (i : ι), f i)) = ↑(⨆ (i : ι), compl (f i))
Theorem: CategoryTheory.Limits.cokernelIsoOfEq_refl
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: ext
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasCokernel f
h : f = f
⊢ cokernelIsoOfEq h = Iso.refl (cokernel f)

tactic: simp [cokernelIsoOfEq]
state_before: case w.h
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasCokernel f
h : f = f
⊢ coequalizer.π f 0 ≫ (cokernelIsoOfEq h).hom = coequalizer.π f 0 ≫ (Iso.refl (cokernel f)).hom
Theorem: Group.rank_le_of_surjective
File: Mathlib/GroupTheory/Finiteness.lean

tactic: obtain ⟨S, hS1, hS2⟩ := Group.rank_spec G
state_before: M : Type ?u.90865
N : Type ?u.90868
inst✝⁶ : Monoid M
inst✝⁵ : AddMonoid N
G : Type u_1
H : Type ?u.90880
inst✝⁴ : Group G
inst✝³ : AddGroup H
G' : Type u_2
inst✝² : Group G'
inst✝¹ : FG G
inst✝ : FG G'
f : G →* G'
hf : Function.Surjective ↑f
⊢ rank G' ≤ rank G

tactic: trans (S.image f).card
state_before: case intro.intro
M : Type ?u.90865
N : Type ?u.90868
inst✝⁶ : Monoid M
inst✝⁵ : AddMonoid N
G : Type u_1
H : Type ?u.90880
inst✝⁴ : Group G
inst✝³ : AddGroup H
G' : Type u_2
inst✝² : Group G'
inst✝¹ : FG G
inst✝ : FG G'
f : G →* G'
hf : Function.Surjective ↑f
S : Finset G
hS1 : Finset.card S = rank G
hS2 : Subgroup.closure ↑S = ⊤
⊢ rank G' ≤ rank G

tactic: apply Group.rank_le
state_before: M : Type ?u.90865
N : Type ?u.90868
inst✝⁶ : Monoid M
inst✝⁵ : AddMonoid N
G : Type u_1
H : Type ?u.90880
inst✝⁴ : Group G
inst✝³ : AddGroup H
G' : Type u_2
inst✝² : Group G'
inst✝¹ : FG G
inst✝ : FG G'
f : G →* G'
hf : Function.Surjective ↑f
S : Finset G
hS1 : Finset.card S = rank G
hS2 : Subgroup.closure ↑S = ⊤
⊢ rank G' ≤ Finset.card (Finset.image (↑f) S)

tactic: rw [Finset.coe_image, ← MonoidHom.map_closure, hS2, Subgroup.map_top_of_surjective f hf]
state_before: case hS
M : Type ?u.90865
N : Type ?u.90868
inst✝⁶ : Monoid M
inst✝⁵ : AddMonoid N
G : Type u_1
H : Type ?u.90880
inst✝⁴ : Group G
inst✝³ : AddGroup H
G' : Type u_2
inst✝² : Group G'
inst✝¹ : FG G
inst✝ : FG G'
f : G →* G'
hf : Function.Surjective ↑f
S : Finset G
hS1 : Finset.card S = rank G
hS2 : Subgroup.closure ↑S = ⊤
⊢ Subgroup.closure ↑(Finset.image (↑f) S) = ⊤

tactic: exact Finset.card_image_le.trans_eq hS1
state_before: M : Type ?u.90865
N : Type ?u.90868
inst✝⁶ : Monoid M
inst✝⁵ : AddMonoid N
G : Type u_1
H : Type ?u.90880
inst✝⁴ : Group G
inst✝³ : AddGroup H
G' : Type u_2
inst✝² : Group G'
inst✝¹ : FG G
inst✝ : FG G'
f : G →* G'
hf : Function.Surjective ↑f
S : Finset G
hS1 : Finset.card S = rank G
hS2 : Subgroup.closure ↑S = ⊤
⊢ Finset.card (Finset.image (↑f) S) ≤ rank G
Theorem: SimpleGraph.degree_le_maxDegree
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: obtain ⟨t, ht : _ = _⟩ := Finset.max_of_mem (mem_image_of_mem (fun v => G.degree v) (mem_univ v))
state_before: ι : Sort ?u.293843
𝕜 : Type ?u.293846
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
⊢ degree G v ≤ maxDegree G

tactic: have := Finset.le_max_of_eq (mem_image_of_mem _ (mem_univ v)) ht
state_before: case intro
ι : Sort ?u.293843
𝕜 : Type ?u.293846
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
t : ℕ
ht : Finset.max (image (fun v => degree G v) univ) = ↑t
⊢ degree G v ≤ maxDegree G

tactic: rwa [maxDegree, ht]
state_before: case intro
ι : Sort ?u.293843
𝕜 : Type ?u.293846
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
t : ℕ
ht : Finset.max (image (fun v => degree G v) univ) = ↑t
this : degree G v ≤ t
⊢ degree G v ≤ maxDegree G
Theorem: LinearMap.IsAdjointPair.smul
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: simp [h _]
state_before: R : Type u_1
R₁ : Type ?u.346295
R₂ : Type ?u.346298
R₃ : Type ?u.346301
M : Type u_2
M₁ : Type u_3
M₂ : Type ?u.346310
Mₗ₁ : Type ?u.346313
Mₗ₁' : Type ?u.346316
Mₗ₂ : Type ?u.346319
Mₗ₂' : Type ?u.346322
K : Type ?u.346325
K₁ : Type ?u.346328
K₂ : Type ?u.346331
V : Type ?u.346334
V₁ : Type ?u.346337
V₂ : Type ?u.346340
n : Type ?u.346343
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M₁
inst✝ : Module R M₁
B F : M →ₗ[R] M →ₗ[R] R
B' : M₁ →ₗ[R] M₁ →ₗ[R] R
f f' : M →ₗ[R] M₁
g g' : M₁ →ₗ[R] M
c : R
h : IsAdjointPair B B' f g
x✝¹ : M
x✝ : M₁
⊢ ↑(↑B' (↑(c • f) x✝¹)) x✝ = ↑(↑B x✝¹) (↑(c • g) x✝)
Theorem: HasSum.toNNReal
File: Mathlib/Topology/Instances/NNReal.lean

tactic: lift y to ℝ≥0 using hy.nonneg hf₀
state_before: α : Type u_1
f : α → ℝ
y : ℝ
hf₀ : ∀ (n : α), 0 ≤ f n
hy : HasSum f y
⊢ HasSum (fun x => Real.toNNReal (f x)) (Real.toNNReal y)

tactic: lift f to α → ℝ≥0 using hf₀
state_before: case intro
α : Type u_1
f : α → ℝ
hf₀ : ∀ (n : α), 0 ≤ f n
y : ℝ≥0
hy : HasSum f ↑y
⊢ HasSum (fun x => Real.toNNReal (f x)) (Real.toNNReal ↑y)

tactic: simpa [hasSum_coe] using hy
state_before: case intro.intro
α : Type u_1
y : ℝ≥0
f : α → ℝ≥0
hy : HasSum (fun i => ↑(f i)) ↑y
⊢ HasSum (fun x => Real.toNNReal ((fun i => ↑(f i)) x)) (Real.toNNReal ↑y)
Theorem: InnerProductGeometry.sin_angle_sub_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 : inner x y = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ Real.sin (angle x (x - y)) = ‖y‖ / ‖x - y‖

tactic: rw [or_comm, ← neg_ne_zero, or_comm] at h0
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ Real.sin (angle x (x - y)) = ‖y‖ / ‖x - y‖

tactic: rw [sub_eq_add_neg, sin_angle_add_of_inner_eq_zero h h0, norm_neg]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
h0 : x ≠ 0 ∨ -y ≠ 0
⊢ Real.sin (angle x (x - y)) = ‖y‖ / ‖x - y‖
Theorem: one_le_padicValNat_of_dvd
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rwa [← PartENat.coe_le_coe, padicValNat_def' hp.out.ne_one hn, ← pow_dvd_iff_le_multiplicity,
  pow_one]
state_before: p n : ℕ
hp : Fact (Nat.Prime p)
hn : 0 < n
div : p ∣ n
⊢ 1 ≤ padicValNat p n
Theorem: Ideal.ramificationIdx_of_not_le
File: Mathlib/NumberTheory/RamificationInertia.lean

tactic: simp
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
h : ¬map f p ≤ P
⊢ map f p ≤ P ^ 0

tactic: simpa using h
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
h : ¬map f p ≤ P
⊢ ¬map f p ≤ P ^ (0 + 1)
Theorem: MeasureTheory.Measure.map_prod_map
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: haveI := hgc.of_map μc hg.aemeasurable
state_before: α : Type u_2
α' : Type ?u.4500248
β : Type u_4
β' : Type ?u.4500254
γ : Type u_3
E : Type ?u.4500260
inst✝⁸ : MeasurableSpace α
inst✝⁷ : MeasurableSpace α'
inst✝⁶ : MeasurableSpace β
inst✝⁵ : MeasurableSpace β'
inst✝⁴ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝³ : NormedAddCommGroup E
inst✝² : SigmaFinite ν
inst✝¹ : SigmaFinite μ
δ : Type u_1
inst✝ : MeasurableSpace δ
f : α → β
g : γ → δ
μa : Measure α
μc : Measure γ
hfa : SigmaFinite (map f μa)
hgc : SigmaFinite (map g μc)
hf : Measurable f
hg : Measurable g
⊢ Measure.prod (map f μa) (map g μc) = map (Prod.map f g) (Measure.prod μa μc)

tactic: refine' prod_eq fun s t hs ht => _
state_before: α : Type u_2
α' : Type ?u.4500248
β : Type u_4
β' : Type ?u.4500254
γ : Type u_3
E : Type ?u.4500260
inst✝⁸ : MeasurableSpace α
inst✝⁷ : MeasurableSpace α'
inst✝⁶ : MeasurableSpace β
inst✝⁵ : MeasurableSpace β'
inst✝⁴ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝³ : NormedAddCommGroup E
inst✝² : SigmaFinite ν
inst✝¹ : SigmaFinite μ
δ : Type u_1
inst✝ : MeasurableSpace δ
f : α → β
g : γ → δ
μa : Measure α
μc : Measure γ
hfa : SigmaFinite (map f μa)
hgc : SigmaFinite (map g μc)
hf : Measurable f
hg : Measurable g
this : SigmaFinite μc
⊢ Measure.prod (map f μa) (map g μc) = map (Prod.map f g) (Measure.prod μa μc)

tactic: rw [map_apply (hf.prod_map hg) (hs.prod ht), map_apply hf hs, map_apply hg ht]
state_before: α : Type u_2
α' : Type ?u.4500248
β : Type u_4
β' : Type ?u.4500254
γ : Type u_3
E : Type ?u.4500260
inst✝⁸ : MeasurableSpace α
inst✝⁷ : MeasurableSpace α'
inst✝⁶ : MeasurableSpace β
inst✝⁵ : MeasurableSpace β'
inst✝⁴ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝³ : NormedAddCommGroup E
inst✝² : SigmaFinite ν
inst✝¹ : SigmaFinite μ
δ : Type u_1
inst✝ : MeasurableSpace δ
f : α → β
g : γ → δ
μa : Measure α
μc : Measure γ
hfa : SigmaFinite (map f μa)
hgc : SigmaFinite (map g μc)
hf : Measurable f
hg : Measurable g
this : SigmaFinite μc
s : Set β
t : Set δ
hs : MeasurableSet s
ht : MeasurableSet t
⊢ ↑↑(map (Prod.map f g) (Measure.prod μa μc)) (s ×ˢ t) = ↑↑(map f μa) s * ↑↑(map g μc) t

tactic: exact prod_prod (f ⁻¹' s) (g ⁻¹' t)
state_before: α : Type u_2
α' : Type ?u.4500248
β : Type u_4
β' : Type ?u.4500254
γ : Type u_3
E : Type ?u.4500260
inst✝⁸ : MeasurableSpace α
inst✝⁷ : MeasurableSpace α'
inst✝⁶ : MeasurableSpace β
inst✝⁵ : MeasurableSpace β'
inst✝⁴ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝³ : NormedAddCommGroup E
inst✝² : SigmaFinite ν
inst✝¹ : SigmaFinite μ
δ : Type u_1
inst✝ : MeasurableSpace δ
f : α → β
g : γ → δ
μa : Measure α
μc : Measure γ
hfa : SigmaFinite (map f μa)
hgc : SigmaFinite (map g μc)
hf : Measurable f
hg : Measurable g
this : SigmaFinite μc
s : Set β
t : Set δ
hs : MeasurableSet s
ht : MeasurableSet t
⊢ ↑↑(Measure.prod μa μc) (Prod.map f g ⁻¹' s ×ˢ t) = ↑↑μa (f ⁻¹' s) * ↑↑μc (g ⁻¹' t)
Theorem: Real.log_le_log
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [← exp_le_exp, exp_log h, exp_log h₁]
state_before: x y : ℝ
h : 0 < x
h₁ : 0 < y
⊢ log x ≤ log y ↔ x ≤ y
Theorem: Matrix.ext_iff
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [h]
state_before: l : Type ?u.131
m : Type u_1
n : Type u_2
o : Type ?u.140
m' : o → Type ?u.145
n' : o → Type ?u.150
R : Type ?u.153
S : Type ?u.156
α : Type v
β : Type w
γ : Type ?u.163
M N : Matrix m n α
h : M = N
⊢ ∀ (i : m) (j : n), M i j = N i j
Theorem: Polynomial.derivative_eval
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: simp_rw [derivative_apply, eval_sum, eval_mul_X_pow, eval_C]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p : R[X]
x : R
⊢ eval x (↑derivative p) = sum p fun n a => a * ↑n * x ^ (n - 1)
Theorem: String.utf8SetAux_of_valid
File: Std/Data/String/Lemmas.lean

tactic: rfl
state_before: c' : Char
cs cs' : List Char
i p : Nat
hp : i + utf8Len [] = p
⊢ utf8SetAux c' ([] ++ []) { byteIdx := i } { byteIdx := p } = [] ++ List.modifyHead (fun x => c') []

tactic: simp [← hp, utf8SetAux]
state_before: c' : Char
cs cs'✝ : List Char
i p : Nat
c : Char
cs' : List Char
hp : i + utf8Len [] = p
⊢ utf8SetAux c' ([] ++ c :: cs') { byteIdx := i } { byteIdx := p } = [] ++ List.modifyHead (fun x => c') (c :: cs')

tactic: simp [utf8SetAux]
state_before: c' : Char
cs✝ cs'✝ : List Char
i p : Nat
c : Char
cs cs' : List Char
hp : i + utf8Len (c :: cs) = p
⊢ utf8SetAux c' (c :: cs ++ cs') { byteIdx := i } { byteIdx := p } = c :: cs ++ List.modifyHead (fun x => c') cs'

tactic: rw [if_neg]
state_before: c' : Char
cs✝ cs'✝ : List Char
i p : Nat
c : Char
cs cs' : List Char
hp : i + utf8Len (c :: cs) = p
⊢ (if { byteIdx := i } = { byteIdx := p } then c' :: (cs ++ cs')
    else c :: utf8SetAux c' (cs ++ cs') ({ byteIdx := i } + c) { byteIdx := p }) =
    c ::
      (cs ++
        match cs' with
        | [] => []
        | a :: l => c' :: l)

tactic: case hnc => rw [← hp]; apply Pos.ne_of_lt (Nat.lt_add_of_pos_right add_csize_pos)
state_before: c' : Char
cs✝ cs'✝ : List Char
i p : Nat
c : Char
cs cs' : List Char
hp : i + utf8Len (c :: cs) = p
⊢ c :: utf8SetAux c' (cs ++ cs') ({ byteIdx := i } + c) { byteIdx := p } =
    c ::
      (cs ++
        match cs' with
        | [] => []
        | a :: l => c' :: l)

case hnc
c' : Char
cs✝ cs'✝ : List Char
i p : Nat
c : Char
cs cs' : List Char
hp : i + utf8Len (c :: cs) = p
⊢ ¬{ byteIdx := i } = { byteIdx := p }

tactic: simpa [Nat.add_assoc, Nat.add_comm] using hp
state_before: c' : Char
cs✝ cs'✝ : List Char
i p : Nat
c : Char
cs cs' : List Char
hp : i + utf8Len (c :: cs) = p
⊢ { byteIdx := i }.byteIdx + csize c + utf8Len cs = p

tactic: rw [← hp]
state_before: c' : Char
cs✝ cs'✝ : List Char
i p : Nat
c : Char
cs cs' : List Char
hp : i + utf8Len (c :: cs) = p
⊢ ¬{ byteIdx := i } = { byteIdx := p }

tactic: apply Pos.ne_of_lt (Nat.lt_add_of_pos_right add_csize_pos)
state_before: c' : Char
cs✝ cs'✝ : List Char
i p : Nat
c : Char
cs cs' : List Char
hp : i + utf8Len (c :: cs) = p
⊢ ¬{ byteIdx := i } = { byteIdx := i + utf8Len (c :: cs) }
Theorem: inf_iInf
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [iInf_inf_eq, iInf_const]
state_before: α : Type u_2
β : Type ?u.102664
β₂ : Type ?u.102667
γ : Type ?u.102670
ι : Sort u_1
ι' : Sort ?u.102676
κ : ι → Sort ?u.102681
κ' : ι' → Sort ?u.102686
inst✝¹ : CompleteLattice α
f✝ g s t : ι → α
a✝ b : α
inst✝ : Nonempty ι
f : ι → α
a : α
⊢ (a ⊓ ⨅ (x : ι), f x) = ⨅ (x : ι), a ⊓ f x
Theorem: even_two
File: Mathlib/Algebra/Parity.lean

tactic: rw[one_add_one_eq_two]
state_before: F : Type ?u.72122
α : Type u_1
β : Type ?u.72128
R : Type ?u.72131
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : α
⊢ 2 = 1 + 1
Theorem: toIocDiv_apply_left
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simp [hp]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ a - -1 • p ∈ Set.Ioc a (a + p)
Theorem: Set.Icc_eq_singleton_iff
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: refine' ⟨fun h => _, _⟩
state_before: α : Type u_1
β : Type ?u.31757
inst✝ : PartialOrder α
a b c : α
⊢ Icc a b = {c} ↔ a = c ∧ b = c

tactic: have hab : a ≤ b := nonempty_Icc.1 (h.symm.subst <| singleton_nonempty c)
state_before: case refine'_1
α : Type u_1
β : Type ?u.31757
inst✝ : PartialOrder α
a b c : α
h : Icc a b = {c}
⊢ a = c ∧ b = c

tactic: exact
  ⟨eq_of_mem_singleton <| h.subst <| left_mem_Icc.2 hab,
    eq_of_mem_singleton <| h.subst <| right_mem_Icc.2 hab⟩
state_before: case refine'_1
α : Type u_1
β : Type ?u.31757
inst✝ : PartialOrder α
a b c : α
h : Icc a b = {c}
hab : a ≤ b
⊢ a = c ∧ b = c

tactic: rintro ⟨rfl, rfl⟩
state_before: case refine'_2
α : Type u_1
β : Type ?u.31757
inst✝ : PartialOrder α
a b c : α
⊢ a = c ∧ b = c → Icc a b = {c}

tactic: exact Icc_self _
state_before: case refine'_2.intro
α : Type u_1
β : Type ?u.31757
inst✝ : PartialOrder α
b : α
⊢ Icc b b = {b}
Theorem: CategoryTheory.CosimplicialObject.δ_comp_δ_self'
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: subst H
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : j = ↑Fin.castSucc i
⊢ δ X i ≫ δ X j = δ X i ≫ δ X (Fin.succ i)

tactic: rw [δ_comp_δ_self]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ δ X i ≫ δ X (↑Fin.castSucc i) = δ X i ≫ δ X (Fin.succ i)
Theorem: Equiv.Perm.sameCycle_extendDomain
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [← extendDomain_zpow, extendDomain_apply_image, Subtype.coe_inj, f.injective.eq_iff]
state_before: ι : Type ?u.206959
α : Type u_2
β : Type u_1
f✝ g : Perm α
p✝ : α → Prop
x y z : α
p : β → Prop
inst✝ : DecidablePred p
f : α ≃ Subtype p
n : ℤ
⊢ ↑(extendDomain g f ^ n) ↑(↑f x) = ↑(↑f y) ↔ ↑(g ^ n) x = y
Theorem: Complex.circleTransformDeriv_periodic
File: Mathlib/MeasureTheory/Integral/CircleTransform.lean

tactic: have := periodic_circleMap
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R : ℝ
z w : ℂ
f : ℂ → E
⊢ Periodic (circleTransformDeriv R z w f) (2 * π)

tactic: simp_rw [Periodic] at *
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R : ℝ
z w : ℂ
f : ℂ → E
this : ∀ (c : ℂ) (R : ℝ), Periodic (circleMap c R) (2 * π)
⊢ Periodic (circleTransformDeriv R z w f) (2 * π)

tactic: intro x
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R : ℝ
z w : ℂ
f : ℂ → E
this : ∀ (c : ℂ) (R x : ℝ), circleMap c R (x + 2 * π) = circleMap c R x
⊢ ∀ (x : ℝ), circleTransformDeriv R z w f (x + 2 * π) = circleTransformDeriv R z w f x

tactic: simp_rw [circleTransformDeriv, this]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R : ℝ
z w : ℂ
f : ℂ → E
this : ∀ (c : ℂ) (R x : ℝ), circleMap c R (x + 2 * π) = circleMap c R x
x : ℝ
⊢ circleTransformDeriv R z w f (x + 2 * π) = circleTransformDeriv R z w f x

tactic: congr 2
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R : ℝ
z w : ℂ
f : ℂ → E
this : ∀ (c : ℂ) (R x : ℝ), circleMap c R (x + 2 * π) = circleMap c R x
x : ℝ
⊢ (2 * ↑π * I)⁻¹ • deriv (circleMap z R) (x + 2 * π) • ((circleMap z R x - w) ^ 2)⁻¹ • f (circleMap z R x) =
    (2 * ↑π * I)⁻¹ • deriv (circleMap z R) x • ((circleMap z R x - w) ^ 2)⁻¹ • f (circleMap z R x)

tactic: simp [this]
state_before: case e_a.e_a
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R : ℝ
z w : ℂ
f : ℂ → E
this : ∀ (c : ℂ) (R x : ℝ), circleMap c R (x + 2 * π) = circleMap c R x
x : ℝ
⊢ deriv (circleMap z R) (x + 2 * π) = deriv (circleMap z R) x
Theorem: Vector.ext
File: Mathlib/Data/Vector/Basic.lean

tactic: rw [hv, hw]
state_before: n : ℕ
α : Type u_1
v : List α
hv : List.length v = n
w : List α
hw : List.length w = n
h : ∀ (m : Fin n), get { val := v, property := hv } m = get { val := w, property := hw } m
⊢ List.length ↑{ val := v, property := hv } = List.length ↑{ val := w, property := hw }