1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: SimpleGraph.Subgraph.singletonSubgraph_connected
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

tactic: refine ⟨⟨?_⟩⟩
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v : V
⊢ (G.singletonSubgraph v).Connected
state_after: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v : V
⊢ (G.singletonSubgraph v).coe.Preconnected

tactic: rintro ⟨a, ha⟩ ⟨b, hb⟩
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v : V
⊢ (G.singletonSubgraph v).coe.Preconnected
state_after: case mk.mk
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v a : V
ha : a ∈ (G.singletonSubgraph v).verts
b : V
hb : b ∈ (G.singletonSubgraph v).verts
⊢ (G.singletonSubgraph v).coe.Reachable ⟨a, ha⟩ ⟨b, hb⟩

tactic: simp only [singletonSubgraph_verts, Set.mem_singleton_iff] at ha hb
state_before: case mk.mk
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v a : V
ha : a ∈ (G.singletonSubgraph v).verts
b : V
hb : b ∈ (G.singletonSubgraph v).verts
⊢ (G.singletonSubgraph v).coe.Reachable ⟨a, ha⟩ ⟨b, hb⟩
state_after: case mk.mk
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v a : V
ha✝ : a ∈ (G.singletonSubgraph v).verts
b : V
hb✝ : b ∈ (G.singletonSubgraph v).verts
ha : a = v
hb : b = v
⊢ (G.singletonSubgraph v).coe.Reachable ⟨a, ha✝⟩ ⟨b, hb✝⟩

tactic: subst_vars
state_before: case mk.mk
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v a : V
ha✝ : a ∈ (G.singletonSubgraph v).verts
b : V
hb✝ : b ∈ (G.singletonSubgraph v).verts
ha : a = v
hb : b = v
⊢ (G.singletonSubgraph v).coe.Reachable ⟨a, ha✝⟩ ⟨b, hb✝⟩
state_after: case mk.mk
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
b : V
ha hb : b = b
⊢ (G.singletonSubgraph b).coe.Reachable ⟨b, ⋯⟩ ⟨b, ⋯⟩

tactic: rfl
state_before: case mk.mk
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
b : V
ha hb : b = b
⊢ (G.singletonSubgraph b).coe.Reachable ⟨b, ⋯⟩ ⟨b, ⋯⟩
state_after: no goals
Theorem: Real.not_summable_indicator_one_div_natCast
File: Mathlib/Analysis/PSeries.lean

tactic: have : NeZero m := ⟨hm⟩
state_before: m : ℕ
hm : m ≠ 0
k : ZMod m
⊢ ¬Summable ({n | ↑n = k}.indicator fun n => 1 / ↑n)
state_after: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
⊢ ¬Summable ({n | ↑n = k}.indicator fun n => 1 / ↑n)

tactic: rw [← summable_nat_add_iff 1]
state_before: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
⊢ ¬Summable ({n | ↑n = k}.indicator fun n => 1 / ↑n)
state_after: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
⊢ ¬Summable fun n => {n | ↑n = k}.indicator (fun n => 1 / ↑n) (n + 1)

tactic: have h (n : ℕ) : {n : ℕ | (n : ZMod m) = k - 1}.indicator (fun n : ℕ ↦ (1 / (n + 1 :) : ℝ)) n =
    if (n : ZMod m) = k - 1 then (1 / (n + 1) : ℝ) else (0 : ℝ) := by
  simp only [indicator_apply, mem_setOf_eq, cast_add, cast_one]
state_before: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
⊢ ¬Summable fun n => {n | ↑n = k}.indicator (fun n => 1 / ↑n) (n + 1)
state_after: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
h : ∀ (n : ℕ), {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n = if ↑n = k - 1 then 1 / (↑n + 1) else 0
⊢ ¬Summable fun n => {n | ↑n = k}.indicator (fun n => 1 / ↑n) (n + 1)

tactic: simp_rw [indicator_apply, mem_setOf, cast_add, cast_one, ← eq_sub_iff_add_eq, ← h]
state_before: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
h : ∀ (n : ℕ), {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n = if ↑n = k - 1 then 1 / (↑n + 1) else 0
⊢ ¬Summable fun n => {n | ↑n = k}.indicator (fun n => 1 / ↑n) (n + 1)
state_after: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
h : ∀ (n : ℕ), {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n = if ↑n = k - 1 then 1 / (↑n + 1) else 0
⊢ ¬Summable fun n => {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n

tactic: rw [summable_indicator_mod_iff (fun n₁ n₂ h ↦ by gcongr) (k - 1)]
state_before: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
h : ∀ (n : ℕ), {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n = if ↑n = k - 1 then 1 / (↑n + 1) else 0
⊢ ¬Summable fun n => {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n
state_after: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
h : ∀ (n : ℕ), {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n = if ↑n = k - 1 then 1 / (↑n + 1) else 0
⊢ ¬Summable fun n => 1 / ↑(n + 1)

tactic: exact mt (summable_nat_add_iff (f := fun n : ℕ ↦ 1 / (n : ℝ)) 1).mp not_summable_one_div_natCast
state_before: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
h : ∀ (n : ℕ), {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n = if ↑n = k - 1 then 1 / (↑n + 1) else 0
⊢ ¬Summable fun n => 1 / ↑(n + 1)
state_after: no goals

tactic: simp only [indicator_apply, mem_setOf_eq, cast_add, cast_one]
state_before: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
n : ℕ
⊢ {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n = if ↑n = k - 1 then 1 / (↑n + 1) else 0
state_after: no goals

tactic: gcongr
state_before: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
h✝ : ∀ (n : ℕ), {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n = if ↑n = k - 1 then 1 / (↑n + 1) else 0
n₁ n₂ : ℕ
h : n₁ ≤ n₂
⊢ 1 / ↑(n₂ + 1) ≤ 1 / ↑(n₁ + 1)
state_after: no goals
Theorem: CategoryTheory.MonoidalCategory.unitors_inv_equal
File: Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean

tactic: coherence
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : MonoidalCategory C
⊢ (λ_ (𝟙_ C)).inv = (ρ_ (𝟙_ C)).inv
state_after: no goals
Theorem: tendsto_ceil_right_pure_floor_add_one
File: Mathlib/Topology/Algebra/Order/Floor.lean

tactic: rw [cast_add, cast_one, add_sub_cancel_right]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
x : α
⊢ ↑(⌊x⌋ + 1) - 1 ≤ x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
x : α
⊢ ↑⌊x⌋ ≤ x

tactic: exact floor_le _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
x : α
⊢ ↑⌊x⌋ ≤ x
state_after: no goals
Theorem: calc_deriv_dist
File: Mathlib/NumberTheory/Padics/Hensel.lean

tactic: simp only [sub_eq_add_neg, add_assoc, hz', add_add_neg_cancel'_right, norm_neg]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
z z' z1 : ℤ_[p]
hz' : z' = z - z1
hz1 : ‖z1‖ = ‖Polynomial.eval z F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖
n : ℕ
hz : ih_gen n z
⊢ ‖z' - z‖ = ‖z1‖
state_after: no goals

tactic: gcongr
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
z z' z1 : ℤ_[p]
hz' : z' = z - z1
hz1 : ‖z1‖ = ‖Polynomial.eval z F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖
n : ℕ
hz : ih_gen n z
⊢ ‖Polynomial.eval z F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖ ≤
    ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2 * T_gen p F a ^ 2 ^ n /
      ‖Polynomial.eval a (Polynomial.derivative F)‖
state_after: case hab
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
z z' z1 : ℤ_[p]
hz' : z' = z - z1
hz1 : ‖z1‖ = ‖Polynomial.eval z F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖
n : ℕ
hz : ih_gen n z
⊢ ‖Polynomial.eval z F‖ ≤ ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2 * T_gen p F a ^ 2 ^ n

tactic: apply hz.2
state_before: case hab
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
z z' z1 : ℤ_[p]
hz' : z' = z - z1
hz1 : ‖z1‖ = ‖Polynomial.eval z F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖
n : ℕ
hz : ih_gen n z
⊢ ‖Polynomial.eval z F‖ ≤ ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2 * T_gen p F a ^ 2 ^ n
state_after: no goals
Theorem: Real.abs_sin_eq_sqrt_one_sub_cos_sq
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← sin_sq, sqrt_sq_eq_abs]
state_before: x✝ y x : ℝ
⊢ |sin x| = √(1 - cos x ^ 2)
state_after: no goals
Theorem: MeasureTheory.snormEssSup_eq_zero_iff
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: simp [EventuallyEq, snormEssSup]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
⊢ snormEssSup f μ = 0 ↔ f =ᶠ[ae μ] 0
state_after: no goals
Theorem: CategoryTheory.OplaxNatTrans.Modification.whiskerRight_naturality
File: Mathlib/CategoryTheory/Bicategory/NaturalTransformation.lean

tactic: simp_rw [associator_inv_naturality_middle_assoc, ← comp_whiskerRight, naturality]
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G : OplaxFunctor B C
η θ ι : F ⟶ G
Γ : Modification η θ
a b c : B
a' : C
f : a ⟶ b
g : (↑G.toPrelaxFunctor).obj b ⟶ a'
⊢ (↑F.toPrelaxFunctor).map f ◁ Γ.app b ▷ g ≫ (α_ ((↑F.toPrelaxFunctor).map f) (θ.app b) g).inv ≫ θ.naturality f ▷ g =
    (α_ ((↑F.toPrelaxFunctor).map f) (η.app b) g).inv ≫ η.naturality f ▷ g ≫ Γ.app a ▷ (↑G.toPrelaxFunctor).map f ▷ g
state_after: no goals
Theorem: disjoint_nhds_atBot
File: Mathlib/Topology/Order/OrderClosed.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : Preorder α
inst✝³ : NoBotOrder α
inst✝² : TopologicalSpace α
inst✝¹ : ClosedIicTopology α
a✝ : α
l : Filter β
inst✝ : l.NeBot
f : β → α
a : α
⊢ Disjoint (𝓝 a) atBot
state_after: no goals
Theorem: HasDerivWithinAt.comp_of_eq
File: Mathlib/Analysis/Calculus/Deriv/Comp.lean

tactic: rw [hy] at hh₂
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
y : 𝕜'
hh₂ : HasDerivWithinAt h₂ h₂' s' y
hh : HasDerivWithinAt h h' s x
hst : MapsTo h s s'
hy : y = h x
⊢ HasDerivWithinAt (h₂ ∘ h) (h₂' * h') s x
state_after: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
y : 𝕜'
hh₂ : HasDerivWithinAt h₂ h₂' s' (h x)
hh : HasDerivWithinAt h h' s x
hst : MapsTo h s s'
hy : y = h x
⊢ HasDerivWithinAt (h₂ ∘ h) (h₂' * h') s x

tactic: exact hh₂.comp x hh hst
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
y : 𝕜'
hh₂ : HasDerivWithinAt h₂ h₂' s' (h x)
hh : HasDerivWithinAt h h' s x
hst : MapsTo h s s'
hy : y = h x
⊢ HasDerivWithinAt (h₂ ∘ h) (h₂' * h') s x
state_after: no goals
Theorem: IsGδ.sUnion
File: Mathlib/Topology/GDelta.lean

tactic: induction S, hS using Set.Finite.dinduction_on with
| H0 => simp
| H1 _ _ ih =>
  simp only [forall_mem_insert, sUnion_insert] at *
  exact h.1.union (ih h.2)
state_before: X : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
inst✝ : TopologicalSpace X
S : Set (Set X)
hS : S.Finite
h : ∀ s ∈ S, IsGδ s
⊢ IsGδ (⋃₀ S)
state_after: no goals

tactic: simp
state_before: case H0
X : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
inst✝ : TopologicalSpace X
S : Set (Set X)
h : ∀ s ∈ ∅, IsGδ s
⊢ IsGδ (⋃₀ ∅)
state_after: no goals

tactic: simp only [forall_mem_insert, sUnion_insert] at *
state_before: case H1
X : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
inst✝ : TopologicalSpace X
S : Set (Set X)
a✝¹ : Set X
s✝ : Set (Set X)
a✝ : a✝¹ ∉ s✝
h✝ : s✝.Finite
ih : (∀ s ∈ s✝, IsGδ s) → IsGδ (⋃₀ s✝)
h : ∀ s ∈ insert a✝¹ s✝, IsGδ s
⊢ IsGδ (⋃₀ insert a✝¹ s✝)
state_after: case H1
X : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
inst✝ : TopologicalSpace X
S : Set (Set X)
a✝¹ : Set X
s✝ : Set (Set X)
a✝ : a✝¹ ∉ s✝
h✝ : s✝.Finite
ih : (∀ s ∈ s✝, IsGδ s) → IsGδ (⋃₀ s✝)
h : IsGδ a✝¹ ∧ ∀ x ∈ s✝, IsGδ x
⊢ IsGδ (a✝¹ ∪ ⋃₀ s✝)

tactic: exact h.1.union (ih h.2)
state_before: case H1
X : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
inst✝ : TopologicalSpace X
S : Set (Set X)
a✝¹ : Set X
s✝ : Set (Set X)
a✝ : a✝¹ ∉ s✝
h✝ : s✝.Finite
ih : (∀ s ∈ s✝, IsGδ s) → IsGδ (⋃₀ s✝)
h : IsGδ a✝¹ ∧ ∀ x ∈ s✝, IsGδ x
⊢ IsGδ (a✝¹ ∪ ⋃₀ s✝)
state_after: no goals
Theorem: pow_mod_natCard
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [eq_comm, ← pow_mod_orderOf, ← Nat.mod_mod_of_dvd n $ orderOf_dvd_natCard _, pow_mod_orderOf]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Fintype G
x : G
n✝ : ℕ
a : G
n : ℕ
⊢ a ^ (n % Nat.card G) = a ^ n
state_after: no goals
Theorem: Filter.nhds_inf
File: Mathlib/Topology/Filter.lean

tactic: simpa only [iInf_bool_eq] using nhds_iInf fun b => cond b l₁ l₂
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
X : Type u_4
Y : Type u_5
l₁ l₂ : Filter α
⊢ 𝓝 (l₁ ⊓ l₂) = 𝓝 l₁ ⊓ 𝓝 l₂
state_after: no goals
Theorem: MeasureTheory.MeasurePreserving.sigmaFinite
File: Mathlib/Dynamics/Ergodic/MeasurePreserving.lean

tactic: rwa [hf.map_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
inst✝¹ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
f : α → β
hf : MeasurePreserving f μa μb
inst✝ : SigmaFinite μb
⊢ SigmaFinite (map f μa)
state_after: no goals
Theorem: Matrix.toLinAlgEquiv_apply
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: rw [Matrix.toLinAlgEquiv'_apply, v₁.equivFun_symm_apply]
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type u_7
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
M : Matrix n n R
v : M₁
⊢ v₁.equivFun.symm ((toLinAlgEquiv' M) ⇑(v₁.repr v)) = ∑ j : n, (M *ᵥ ⇑(v₁.repr v)) j • v₁ j
state_after: no goals
Theorem: Nat.floor_lt_one
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [Nat.cast_one]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
ha : 0 ≤ a
⊢ a < ↑1 ↔ a < 1
state_after: no goals
Theorem: Equiv.Perm.sign_eq_sign_of_equiv
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: have hg : g = (e.symm.trans f).trans e := Equiv.ext <| by simp [h]
state_before: α : Type u
inst✝³ : DecidableEq α
β : Type v
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
f : Perm α
g : Perm β
e : α ≃ β
h : ∀ (x : α), e (f x) = g (e x)
⊢ sign f = sign g
state_after: α : Type u
inst✝³ : DecidableEq α
β : Type v
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
f : Perm α
g : Perm β
e : α ≃ β
h : ∀ (x : α), e (f x) = g (e x)
hg : g = (e.symm.trans f).trans e
⊢ sign f = sign g

tactic: rw [hg, sign_symm_trans_trans]
state_before: α : Type u
inst✝³ : DecidableEq α
β : Type v
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
f : Perm α
g : Perm β
e : α ≃ β
h : ∀ (x : α), e (f x) = g (e x)
hg : g = (e.symm.trans f).trans e
⊢ sign f = sign g
state_after: no goals

tactic: simp [h]
state_before: α : Type u
inst✝³ : DecidableEq α
β : Type v
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
f : Perm α
g : Perm β
e : α ≃ β
h : ∀ (x : α), e (f x) = g (e x)
⊢ ∀ (x : β), g x = ((e.symm.trans f).trans e) x
state_after: no goals
Theorem: Cardinal.ofENat_lt_nat
File: Mathlib/SetTheory/Cardinal/ENat.lean

tactic: norm_cast
state_before: m : ℕ∞
n : ℕ
⊢ ↑m < ↑n ↔ m < ↑n
state_after: no goals
Theorem: Equiv.pointReflection_midpoint_left
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: rw [midpoint, pointReflection_apply, lineMap_apply, vadd_vsub, vadd_vadd, ← add_smul, ← two_mul,
  mul_invOf_self, one_smul, vsub_vadd]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y✝ z x y : P
⊢ (pointReflection (midpoint R x y)) x = y
state_after: no goals
Theorem: List.isRotated_append
File: Mathlib/Data/List/Rotate.lean

tactic: simp
state_before: α : Type u
l l' : List α
⊢ (l ++ l').rotate l.length = l' ++ l
state_after: no goals
Theorem: Subsemigroup.top_prod
File: Mathlib/Algebra/Group/Subsemigroup/Operations.lean

tactic: simp [mem_prod, MulHom.coe_snd]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
σ : Type u_4
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S : Subsemigroup M
s : Subsemigroup N
x : M × N
⊢ x ∈ ⊤.prod s ↔ x ∈ comap (MulHom.snd M N) s
state_after: no goals
Theorem: Finset.nnnorm_prod_le'
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simp [NNReal.coe_prod]
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝¹ : SeminormedRing α✝
α : Type u_5
inst✝ : NormedCommRing α
s : Finset ι
hs : s.Nonempty
f : ι → α
⊢ ∏ i ∈ s, ‖f i‖ = (fun a => ↑a) (∏ i ∈ s, ‖f i‖₊)
state_after: no goals
Theorem: MeasureTheory.FiniteMeasure.prod_apply
File: Mathlib/MeasureTheory/Measure/FiniteMeasureProd.lean

tactic: simp [coeFn_def, Measure.prod_apply s_mble]
state_before: α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
s : Set (α × β)
s_mble : MeasurableSet s
⊢ (μ.prod ν) s = (∫⁻ (x : α), ↑ν (Prod.mk x ⁻¹' s) ∂↑μ).toNNReal
state_after: no goals
Theorem: CategoryTheory.Iso.op_unop
File: Mathlib/CategoryTheory/Opposites.lean

tactic: (ext; rfl)
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X✝ Y✝ X Y : C
f : X ≅ Y
⊢ f.op.unop = f
state_after: no goals

tactic: ext
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X✝ Y✝ X Y : C
f : X ≅ Y
⊢ f.op.unop = f
state_after: case w
C : Type u₁
inst✝ : Category.{v₁, u₁} C
X✝ Y✝ X Y : C
f : X ≅ Y
⊢ f.op.unop.hom = f.hom

tactic: rfl
state_before: case w
C : Type u₁
inst✝ : Category.{v₁, u₁} C
X✝ Y✝ X Y : C
f : X ≅ Y
⊢ f.op.unop.hom = f.hom
state_after: no goals
Theorem: HurwitzZeta.sinKernel_def
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

tactic: rw [sinKernel, Function.Periodic.lift_coe, re_eq_add_conj, map_div₀, jacobiTheta₂'_conj]
state_before: a x : ℝ
⊢ ↑(sinKernel (↑a) x) = jacobiTheta₂' (↑a) (I * ↑x) / (-2 * ↑π)
state_after: a x : ℝ
⊢ (jacobiTheta₂' (↑a) (I * ↑x) / (-2 * ↑π) +
        jacobiTheta₂' ((starRingEnd ℂ) ↑a) (-(starRingEnd ℂ) (I * ↑x)) / (starRingEnd ℂ) (-2 * ↑π)) /
      2 =
    jacobiTheta₂' (↑a) (I * ↑x) / (-2 * ↑π)

tactic: simp_rw [map_mul, conj_I, conj_ofReal, map_neg, map_ofNat, neg_mul, neg_neg, half_add_self]
state_before: a x : ℝ
⊢ (jacobiTheta₂' (↑a) (I * ↑x) / (-2 * ↑π) +
        jacobiTheta₂' ((starRingEnd ℂ) ↑a) (-(starRingEnd ℂ) (I * ↑x)) / (starRingEnd ℂ) (-2 * ↑π)) /
      2 =
    jacobiTheta₂' (↑a) (I * ↑x) / (-2 * ↑π)
state_after: no goals
Theorem: Vector.scanl_head
File: Mathlib/Data/Vector/Basic.lean

tactic: cases n
state_before: n : ℕ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α n
⊢ (scanl f b v).head = b
state_after: case zero
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α 0
⊢ (scanl f b v).head = b

case succ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
n✝ : ℕ
v : Vector α (n✝ + 1)
⊢ (scanl f b v).head = b

tactic: have : v = nil := by simp only [Nat.zero_eq, eq_iff_true_of_subsingleton]
state_before: case zero
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α 0
⊢ (scanl f b v).head = b
state_after: case zero
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α 0
this : v = nil
⊢ (scanl f b v).head = b

tactic: simp only [this, scanl_nil, head_cons]
state_before: case zero
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α 0
this : v = nil
⊢ (scanl f b v).head = b
state_after: no goals

tactic: simp only [Nat.zero_eq, eq_iff_true_of_subsingleton]
state_before: α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α 0
⊢ v = nil
state_after: no goals

tactic: rw [← cons_head_tail v]
state_before: case succ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
n✝ : ℕ
v : Vector α (n✝ + 1)
⊢ (scanl f b v).head = b
state_after: case succ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
n✝ : ℕ
v : Vector α (n✝ + 1)
⊢ (scanl f b (v.head ::ᵥ v.tail)).head = b

tactic: simp only [← get_zero, get_eq_get, toList_scanl, toList_cons, List.scanl, Fin.val_zero,
  List.get]
state_before: case succ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
n✝ : ℕ
v : Vector α (n✝ + 1)
⊢ (scanl f b (v.head ::ᵥ v.tail)).head = b
state_after: no goals
Theorem: CompleteLattice.bot_continuous
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: rw [← sSup_empty]
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
⊢ Continuous ⊥
state_after: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
⊢ Continuous (sSup ∅)

tactic: exact sSup_continuous _ fun f hf => hf.elim
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
⊢ Continuous (sSup ∅)
state_after: no goals
Theorem: Rep.ihom_ev_app_hom
File: Mathlib/RepresentationTheory/Rep.lean

tactic: ext
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B✝ C A B : Rep k G
⊢ ((ihom.ev A).app B).hom =
    (TensorProduct.uncurry k (CoeSort.coe A) (CoeSort.coe A →ₗ[k] CoeSort.coe B) (CoeSort.coe B)) LinearMap.id.flip
state_after: case h
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B✝ C A B : Rep k G
x✝ : ↑((ihom A ⋙ tensorLeft A).obj B).V
⊢ ((ihom.ev A).app B).hom x✝ =
    ((TensorProduct.uncurry k (CoeSort.coe A) (CoeSort.coe A →ₗ[k] CoeSort.coe B) (CoeSort.coe B)) LinearMap.id.flip) x✝

tactic: rfl
state_before: case h
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B✝ C A B : Rep k G
x✝ : ↑((ihom A ⋙ tensorLeft A).obj B).V
⊢ ((ihom.ev A).app B).hom x✝ =
    ((TensorProduct.uncurry k (CoeSort.coe A) (CoeSort.coe A →ₗ[k] CoeSort.coe B) (CoeSort.coe B)) LinearMap.id.flip) x✝
state_after: no goals
Theorem: Int.map_floor
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← map_intCast f, hf.le_iff_le]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁵ : LinearOrderedRing α
inst✝⁴ : LinearOrderedRing β
inst✝³ : FloorRing α
inst✝² : FloorRing β
inst✝¹ : FunLike F α β
inst✝ : RingHomClass F α β
a✝ : α
b : β
f : F
hf : StrictMono ⇑f
a : α
n : ℤ
⊢ ↑n ≤ f a ↔ ↑n ≤ a
state_after: no goals
Theorem: Bornology.isVonNBounded_iff_smul_tendsto_zero
File: Mathlib/Analysis/LocallyConvex/Bounded.lean

tactic: exact hε self_mem_nhdsWithin
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
E' : Type u_4
F : Type u_5
ι : Type u_6
𝕝 : Type u_7
inst✝⁷ : NormedField 𝕜
inst✝⁶ : NontriviallyNormedField 𝕝
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : Module 𝕝 E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousSMul 𝕝 E
ε : ι → 𝕝
l : Filter ι
inst✝ : l.NeBot
hε : Tendsto ε l (𝓝[≠] 0)
S : Set E
⊢ ∀ᶠ (n : ι) in l, ε n ≠ 0
state_after: no goals