1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: HasFDerivAt.le_of_lipschitzOn
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: refine hf.le_of_lip' C.coe_nonneg ?_
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s✝ t : Set E
L L₁ L₂ : Filter E
f : E → F
f' : E →L[𝕜] F
x₀ : E
hf : HasFDerivAt f f' x₀
s : Set E
hs : s ∈ 𝓝 x₀
C : ℝ≥0
hlip : LipschitzOnWith C f s
⊢ ‖f'‖ ≤ ↑C
state_after: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s✝ t : Set E
L L₁ L₂ : Filter E
f : E → F
f' : E →L[𝕜] F
x₀ : E
hf : HasFDerivAt f f' x₀
s : Set E
hs : s ∈ 𝓝 x₀
C : ℝ≥0
hlip : LipschitzOnWith C f s
⊢ ∀ᶠ (x : E) in 𝓝 x₀, ‖f x - f x₀‖ ≤ ↑C * ‖x - x₀‖

tactic: filter_upwards [hs] with x hx using hlip.norm_sub_le hx (mem_of_mem_nhds hs)
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s✝ t : Set E
L L₁ L₂ : Filter E
f : E → F
f' : E →L[𝕜] F
x₀ : E
hf : HasFDerivAt f f' x₀
s : Set E
hs : s ∈ 𝓝 x₀
C : ℝ≥0
hlip : LipschitzOnWith C f s
⊢ ∀ᶠ (x : E) in 𝓝 x₀, ‖f x - f x₀‖ ≤ ↑C * ‖x - x₀‖
state_after: no goals
Theorem: padicNorm.zero_of_padicNorm_eq_zero
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: apply by_contradiction
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
h : padicNorm p q = 0
⊢ q = 0
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
h : padicNorm p q = 0
⊢ ¬q = 0 → False

tactic: intro hq
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
h : padicNorm p q = 0
⊢ ¬q = 0 → False
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
h : padicNorm p q = 0
hq : ¬q = 0
⊢ False

tactic: unfold padicNorm at h
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
h : padicNorm p q = 0
hq : ¬q = 0
⊢ False
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
h : (if q = 0 then 0 else ↑p ^ (-padicValRat p q)) = 0
hq : ¬q = 0
⊢ False

tactic: rw [if_neg hq] at h
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
h : (if q = 0 then 0 else ↑p ^ (-padicValRat p q)) = 0
hq : ¬q = 0
⊢ False
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
h : ↑p ^ (-padicValRat p q) = 0
hq : ¬q = 0
⊢ False

tactic: apply absurd h
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
h : ↑p ^ (-padicValRat p q) = 0
hq : ¬q = 0
⊢ False
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
h : ↑p ^ (-padicValRat p q) = 0
hq : ¬q = 0
⊢ ¬↑p ^ (-padicValRat p q) = 0

tactic: apply zpow_ne_zero
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
h : ↑p ^ (-padicValRat p q) = 0
hq : ¬q = 0
⊢ ¬↑p ^ (-padicValRat p q) = 0
state_after: case a.a
p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
h : ↑p ^ (-padicValRat p q) = 0
hq : ¬q = 0
⊢ ↑p ≠ 0

tactic: exact mod_cast hp.1.ne_zero
state_before: case a.a
p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
h : ↑p ^ (-padicValRat p q) = 0
hq : ¬q = 0
⊢ ↑p ≠ 0
state_after: no goals
Theorem: List.countP_cons
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

tactic: by_cases h : p a <;> simp [h]
state_before: α : Type u_1
p q : α → Bool
a : α
l : List α
⊢ countP p (a :: l) = countP p l + if p a = true then 1 else 0
state_after: no goals
Theorem: LazyList.mem_cons
File: Mathlib/Data/LazyList/Basic.lean

tactic: simp [Membership.mem, LazyList.Mem]
state_before: α : Type u_1
x y : α
ys : Thunk (LazyList α)
⊢ x ∈ cons y ys ↔ x = y ∨ x ∈ ys.get
state_after: no goals
Theorem: Unitization.inl_star
File: Mathlib/Algebra/Algebra/Unitization.lean

tactic: simp only [snd_star, star_zero, snd_inl]
state_before: R : Type u_1
A : Type u_2
inst✝² : Star R
inst✝¹ : AddMonoid A
inst✝ : StarAddMonoid A
r : R
⊢ (inl (star r)).snd = (star (inl r)).snd
state_after: no goals
Theorem: Filter.Eventually.diag_of_prod_right
File: Mathlib/Order/Filter/Prod.lean

tactic: intro h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter γ
p : α × γ × γ → Prop
⊢ (∀ᶠ (x : α × γ × γ) in f ×ˢ g ×ˢ g, p x) → ∀ᶠ (x : α × γ) in f ×ˢ g, p (x.1, x.2, x.2)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter γ
p : α × γ × γ → Prop
h : ∀ᶠ (x : α × γ × γ) in f ×ˢ g ×ˢ g, p x
⊢ ∀ᶠ (x : α × γ) in f ×ˢ g, p (x.1, x.2, x.2)

tactic: obtain ⟨t, ht, s, hs, hst⟩ := eventually_prod_iff.1 h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter γ
p : α × γ × γ → Prop
h : ∀ᶠ (x : α × γ × γ) in f ×ˢ g ×ˢ g, p x
⊢ ∀ᶠ (x : α × γ) in f ×ˢ g, p (x.1, x.2, x.2)
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t✝ : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter γ
p : α × γ × γ → Prop
h : ∀ᶠ (x : α × γ × γ) in f ×ˢ g ×ˢ g, p x
t : α → Prop
ht : ∀ᶠ (x : α) in f, t x
s : γ × γ → Prop
hs : ∀ᶠ (y : γ × γ) in g ×ˢ g, s y
hst : ∀ {x : α}, t x → ∀ {y : γ × γ}, s y → p (x, y)
⊢ ∀ᶠ (x : α × γ) in f ×ˢ g, p (x.1, x.2, x.2)

tactic: exact (ht.prod_mk hs.diag_of_prod).mono fun x hx => by simp only [hst hx.1 hx.2]
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t✝ : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter γ
p : α × γ × γ → Prop
h : ∀ᶠ (x : α × γ × γ) in f ×ˢ g ×ˢ g, p x
t : α → Prop
ht : ∀ᶠ (x : α) in f, t x
s : γ × γ → Prop
hs : ∀ᶠ (y : γ × γ) in g ×ˢ g, s y
hst : ∀ {x : α}, t x → ∀ {y : γ × γ}, s y → p (x, y)
⊢ ∀ᶠ (x : α × γ) in f ×ˢ g, p (x.1, x.2, x.2)
state_after: no goals

tactic: simp only [hst hx.1 hx.2]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t✝ : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter γ
p : α × γ × γ → Prop
h : ∀ᶠ (x : α × γ × γ) in f ×ˢ g ×ˢ g, p x
t : α → Prop
ht : ∀ᶠ (x : α) in f, t x
s : γ × γ → Prop
hs : ∀ᶠ (y : γ × γ) in g ×ˢ g, s y
hst : ∀ {x : α}, t x → ∀ {y : γ × γ}, s y → p (x, y)
x : α × γ
hx : t x.1 ∧ s (x.2, x.2)
⊢ p (x.1, x.2, x.2)
state_after: no goals
Theorem: DFinsupp.filter_single_pos
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: rw [filter_single, if_pos h]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
p : ι → Prop
inst✝ : DecidablePred p
i : ι
x : β i
h : p i
⊢ filter p (single i x) = single i x
state_after: no goals
Theorem: CategoryTheory.IsPushout.of_is_bilimit'
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: refine IsPushout.of_right ?_ (by simp) (IsPushout.inl_snd' h)
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : b.IsBilimit
⊢ IsPushout b.fst b.snd 0 0
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : b.IsBilimit
⊢ IsPushout (b.inl ≫ b.fst) 0 0 (0 ≫ 0)

tactic: simp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : b.IsBilimit
⊢ IsPushout (b.inl ≫ b.fst) 0 0 (0 ≫ 0)
state_after: no goals

tactic: simp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : b.IsBilimit
⊢ b.fst ≫ 0 = b.snd ≫ 0
state_after: no goals
Theorem: Metric.thickening_singleton
File: Mathlib/Topology/MetricSpace/Thickening.lean

tactic: ext
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
X : Type u
inst✝ : PseudoMetricSpace X
δ : ℝ
x : X
⊢ thickening δ {x} = ball x δ
state_after: case h
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝¹ : α
X : Type u
inst✝ : PseudoMetricSpace X
δ : ℝ
x x✝ : X
⊢ x✝ ∈ thickening δ {x} ↔ x✝ ∈ ball x δ

tactic: simp [mem_thickening_iff]
state_before: case h
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝¹ : α
X : Type u
inst✝ : PseudoMetricSpace X
δ : ℝ
x x✝ : X
⊢ x✝ ∈ thickening δ {x} ↔ x✝ ∈ ball x δ
state_after: no goals
Theorem: Subalgebra.finrank_eq_one_iff
File: Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean

tactic: rw [← Subalgebra.rank_eq_one_iff]
state_before: F : Type u_1
E : Type u_2
inst✝⁵ : CommRing F
inst✝⁴ : StrongRankCondition F
inst✝³ : Ring E
inst✝² : Algebra F E
S : Subalgebra F E
inst✝¹ : Nontrivial E
inst✝ : Module.Free F ↥S
⊢ finrank F ↥S = 1 ↔ S = ⊥
state_after: F : Type u_1
E : Type u_2
inst✝⁵ : CommRing F
inst✝⁴ : StrongRankCondition F
inst✝³ : Ring E
inst✝² : Algebra F E
S : Subalgebra F E
inst✝¹ : Nontrivial E
inst✝ : Module.Free F ↥S
⊢ finrank F ↥S = 1 ↔ Module.rank F ↥S = 1

tactic: exact toNat_eq_iff one_ne_zero
state_before: F : Type u_1
E : Type u_2
inst✝⁵ : CommRing F
inst✝⁴ : StrongRankCondition F
inst✝³ : Ring E
inst✝² : Algebra F E
S : Subalgebra F E
inst✝¹ : Nontrivial E
inst✝ : Module.Free F ↥S
⊢ finrank F ↥S = 1 ↔ Module.rank F ↥S = 1
state_after: no goals
Theorem: Fin.coe_fin_one
File: Mathlib/Data/Fin/Basic.lean

tactic: simp [Subsingleton.elim a 0]
state_before: n m : ℕ
a : Fin 1
⊢ ↑a = 0
state_after: no goals
Theorem: Polynomial.scaleRoots_mul
File: Mathlib/RingTheory/Polynomial/ScaleRoots.lean

tactic: ext
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝³ : Semiring S
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Field K
p : R[X]
r s : R
⊢ p.scaleRoots (r * s) = (p.scaleRoots r).scaleRoots s
state_after: case a
R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝³ : Semiring S
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Field K
p : R[X]
r s : R
n✝ : ℕ
⊢ (p.scaleRoots (r * s)).coeff n✝ = ((p.scaleRoots r).scaleRoots s).coeff n✝

tactic: simp [mul_pow, mul_assoc]
state_before: case a
R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝³ : Semiring S
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Field K
p : R[X]
r s : R
n✝ : ℕ
⊢ (p.scaleRoots (r * s)).coeff n✝ = ((p.scaleRoots r).scaleRoots s).coeff n✝
state_after: no goals
Theorem: Nat.le_one_iff_eq_zero_or_eq_one
File: Mathlib/Data/Nat/Defs.lean

tactic: simp [le_succ_iff]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ ∀ {n : ℕ}, n ≤ 1 ↔ n = 0 ∨ n = 1
state_after: no goals
Theorem: Orientation.two_zsmul_oangle_smul_left_self
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

tactic: rcases lt_or_le r 0 with (h | h) <;> simp [h]
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x : V
r : ℝ
⊢ 2 • o.oangle (r • x) x = 0
state_after: no goals
Theorem: List.takeD_left'
File: Mathlib/Data/List/Basic.lean

tactic: rw [← h]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ l₁ l₂ : List α
n : ℕ
a : α
h : l₁.length = n
⊢ takeD n (l₁ ++ l₂) a = l₁
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ l₁ l₂ : List α
n : ℕ
a : α
h : l₁.length = n
⊢ takeD l₁.length (l₁ ++ l₂) a = l₁

tactic: apply takeD_left
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ l₁ l₂ : List α
n : ℕ
a : α
h : l₁.length = n
⊢ takeD l₁.length (l₁ ++ l₂) a = l₁
state_after: no goals
Theorem: MeasureTheory.cylinder_empty
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

tactic: rw [cylinder, preimage_empty]
state_before: ι : Type u_1
α : ι → Type u_2
s : Finset ι
⊢ cylinder s ∅ = ∅
state_after: no goals
Theorem: autEquivZmod_symm_apply_natCast
File: Mathlib/FieldTheory/KummerExtension.lean

tactic: simpa only [Int.cast_natCast, zpow_natCast] using autEquivZmod_symm_apply_intCast H L hα hζ m
state_before: K : Type u
inst✝³ : Field K
n : ℕ
hζ✝ : (primitiveRoots n K).Nonempty
hn : 0 < n
a : K
H : Irreducible (X ^ n - C a)
L : Type u_1
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsSplittingField K L (X ^ n - C a)
α : L
hα : α ^ n = (algebraMap K L) a
ζ : K
hζ : IsPrimitiveRoot ζ n
m : ℕ
⊢ ((autEquivZmod H L hζ).symm (Multiplicative.ofAdd ↑m)) α = ζ ^ m • α
state_after: no goals
Theorem: Multiset.toDFinsupp_replicate
File: Mathlib/Data/DFinsupp/Multiset.lean

tactic: ext i
state_before: α : Type u_1
β : α → Type u_2
inst✝ : DecidableEq α
s t : Multiset α
a : α
n : ℕ
⊢ toDFinsupp (replicate n a) = DFinsupp.single a n
state_after: case h
α : Type u_1
β : α → Type u_2
inst✝ : DecidableEq α
s t : Multiset α
a : α
n : ℕ
i : α
⊢ (toDFinsupp (replicate n a)) i = (DFinsupp.single a n) i

tactic: dsimp [toDFinsupp]
state_before: case h
α : Type u_1
β : α → Type u_2
inst✝ : DecidableEq α
s t : Multiset α
a : α
n : ℕ
i : α
⊢ (toDFinsupp (replicate n a)) i = (DFinsupp.single a n) i
state_after: case h
α : Type u_1
β : α → Type u_2
inst✝ : DecidableEq α
s t : Multiset α
a : α
n : ℕ
i : α
⊢ count i (replicate n a) = (DFinsupp.single a n) i

tactic: simp [count_replicate, eq_comm]
state_before: case h
α : Type u_1
β : α → Type u_2
inst✝ : DecidableEq α
s t : Multiset α
a : α
n : ℕ
i : α
⊢ count i (replicate n a) = (DFinsupp.single a n) i
state_after: no goals
Theorem: Matrix.blockDiagonal_diagonal
File: Mathlib/Data/Matrix/Block.lean

tactic: ext ⟨i, k⟩ ⟨j, k'⟩
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝³ : DecidableEq o
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : DecidableEq m
d : o → m → α
⊢ (blockDiagonal fun k => diagonal (d k)) = diagonal fun ik => d ik.2 ik.1
state_after: case a.mk.mk
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝³ : DecidableEq o
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : DecidableEq m
d : o → m → α
i : m
k : o
j : m
k' : o
⊢ blockDiagonal (fun k => diagonal (d k)) (i, k) (j, k') = diagonal (fun ik => d ik.2 ik.1) (i, k) (j, k')

tactic: simp only [blockDiagonal_apply, diagonal_apply, Prod.mk.inj_iff, ← ite_and]
state_before: case a.mk.mk
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝³ : DecidableEq o
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : DecidableEq m
d : o → m → α
i : m
k : o
j : m
k' : o
⊢ blockDiagonal (fun k => diagonal (d k)) (i, k) (j, k') = diagonal (fun ik => d ik.2 ik.1) (i, k) (j, k')
state_after: case a.mk.mk
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝³ : DecidableEq o
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : DecidableEq m
d : o → m → α
i : m
k : o
j : m
k' : o
⊢ (if k = k' ∧ i = j then d k i else 0) = if i = j ∧ k = k' then d k i else 0

tactic: congr 1
state_before: case a.mk.mk
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝³ : DecidableEq o
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : DecidableEq m
d : o → m → α
i : m
k : o
j : m
k' : o
⊢ (if k = k' ∧ i = j then d k i else 0) = if i = j ∧ k = k' then d k i else 0
state_after: case a.mk.mk.e_c
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝³ : DecidableEq o
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : DecidableEq m
d : o → m → α
i : m
k : o
j : m
k' : o
⊢ (k = k' ∧ i = j) = (i = j ∧ k = k')

tactic: rw [and_comm]
state_before: case a.mk.mk.e_c
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝³ : DecidableEq o
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : DecidableEq m
d : o → m → α
i : m
k : o
j : m
k' : o
⊢ (k = k' ∧ i = j) = (i = j ∧ k = k')
state_after: no goals
Theorem: CategoryTheory.Subgroupoid.IsWide.eqToHom_mem
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

tactic: cases h
state_before: C : Type u
inst✝ : Groupoid C
S✝ S : Subgroupoid C
Sw : S.IsWide
c d : C
h : c = d
⊢ eqToHom h ∈ S.arrows c d
state_after: case refl
C : Type u
inst✝ : Groupoid C
S✝ S : Subgroupoid C
Sw : S.IsWide
c : C
⊢ eqToHom ⋯ ∈ S.arrows c c

tactic: simp only [eqToHom_refl]
state_before: case refl
C : Type u
inst✝ : Groupoid C
S✝ S : Subgroupoid C
Sw : S.IsWide
c : C
⊢ eqToHom ⋯ ∈ S.arrows c c
state_after: case refl
C : Type u
inst✝ : Groupoid C
S✝ S : Subgroupoid C
Sw : S.IsWide
c : C
⊢ 𝟙 c ∈ S.arrows c c

tactic: apply Sw.id_mem c
state_before: case refl
C : Type u
inst✝ : Groupoid C
S✝ S : Subgroupoid C
Sw : S.IsWide
c : C
⊢ 𝟙 c ∈ S.arrows c c
state_after: no goals
Theorem: LieDerivation.lie_coe_lieDerivation_apply
File: Mathlib/Algebra/Lie/Derivation/Basic.lean

tactic: ext
state_before: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
D : LieDerivation R L M
⊢ ⁅x, ↑D⁆ = ↑⁅x, D⁆
state_after: case h
R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
D : LieDerivation R L M
x✝ : L
⊢ ⁅x, ↑D⁆ x✝ = ↑⁅x, D⁆ x✝

tactic: simp
state_before: case h
R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
D : LieDerivation R L M
x✝ : L
⊢ ⁅x, ↑D⁆ x✝ = ↑⁅x, D⁆ x✝
state_after: no goals
Theorem: Real.Angle.two_zsmul_toReal_eq_two_mul_sub_two_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [two_zsmul, ← two_nsmul, two_nsmul_toReal_eq_two_mul_sub_two_pi]
state_before: θ : Angle
⊢ (2 • θ).toReal = 2 * θ.toReal - 2 * π ↔ π / 2 < θ.toReal
state_after: no goals
Theorem: Fin.insertNth_comp_rev
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: funext x
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
β : Type v
α : Type u_1
i : Fin (n + 1)
x : α
p : Fin n → α
⊢ i.insertNth x p ∘ rev = i.rev.insertNth x (p ∘ rev)
state_after: case h
m n : ℕ
α✝ : Fin (n + 1) → Type u
β : Type v
α : Type u_1
i : Fin (n + 1)
x✝ : α
p : Fin n → α
x : Fin (n + 1)
⊢ (i.insertNth x✝ p ∘ rev) x = i.rev.insertNth x✝ (p ∘ rev) x

tactic: apply insertNth_rev
state_before: case h
m n : ℕ
α✝ : Fin (n + 1) → Type u
β : Type v
α : Type u_1
i : Fin (n + 1)
x✝ : α
p : Fin n → α
x : Fin (n + 1)
⊢ (i.insertNth x✝ p ∘ rev) x = i.rev.insertNth x✝ (p ∘ rev) x
state_after: no goals
Theorem: Set.apply_mulIndicator_symmDiff
File: Mathlib/Algebra/Group/Indicator.lean

tactic: by_cases hs : x ∈ s <;> by_cases ht : x ∈ t <;> simp [mem_symmDiff, *]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
inst✝ : Group G
s✝ t✝ : Set α
f✝ g✝ : α → G
a : α
g : G → β
hg : ∀ (x : G), g x⁻¹ = g x
s t : Set α
f : α → G
x : α
⊢ g ((s ∆ t).mulIndicator f x) = g (s.mulIndicator f x / t.mulIndicator f x)
state_after: no goals
Theorem: ContDiff.sub
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f g : E → F
hf : ContDiff 𝕜 n f
hg : ContDiff 𝕜 n g
⊢ ContDiff 𝕜 n fun x => f x - g x
state_after: no goals
Theorem: HahnSeries.SummableFamily.hsum_sub
File: Mathlib/RingTheory/HahnSeries/Summable.lean

tactic: rw [← lsum_apply, LinearMap.map_sub, lsum_apply, lsum_apply]
state_before: Γ : Type u_1
R✝ : Type u_2
inst✝² : OrderedCancelAddCommMonoid Γ
inst✝¹ : Semiring R✝
α : Type u_3
R : Type u_4
inst✝ : Ring R
s t : SummableFamily Γ R α
⊢ (s - t).hsum = s.hsum - t.hsum
state_after: no goals
Theorem: Nat.eq_sqrt'
File: Mathlib/Data/Nat/Defs.lean

tactic: simpa only [Nat.pow_two] using eq_sqrt
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ a = n.sqrt ↔ a ^ 2 ≤ n ∧ n < (a + 1) ^ 2
state_after: no goals
Theorem: exists_pos_left_iff_sameRay
File: Mathlib/LinearAlgebra/Ray.lean

tactic: refine ⟨fun h => ?_, fun h => h.exists_pos_left hx hy⟩
state_before: R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hy : y ≠ 0
⊢ (∃ r, 0 < r ∧ r • x = y) ↔ SameRay R x y
state_after: R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hy : y ≠ 0
h : ∃ r, 0 < r ∧ r • x = y
⊢ SameRay R x y

tactic: rcases h with ⟨r, hr, rfl⟩
state_before: R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hy : y ≠ 0
h : ∃ r, 0 < r ∧ r • x = y
⊢ SameRay R x y
state_after: case intro.intro
R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x : M
hx : x ≠ 0
r : R
hr : 0 < r
hy : r • x ≠ 0
⊢ SameRay R x (r • x)

tactic: exact SameRay.sameRay_pos_smul_right x hr
state_before: case intro.intro
R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x : M
hx : x ≠ 0
r : R
hr : 0 < r
hy : r • x ≠ 0
⊢ SameRay R x (r • x)
state_after: no goals