1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Equiv.uniformEmbedding
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: rwa [← Equiv.prodCongr_apply, ← map_equiv_symm]
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
inst✝⁴ : UniformSpace α✝
inst✝³ : UniformSpace β✝
inst✝² : UniformSpace γ
α : Type u_1
β : Type u_2
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α ≃ β
h₁ : UniformContinuous ⇑f
h₂ : UniformContinuous ⇑f.symm
⊢ comap (Prod.map ⇑f ⇑f) (𝓤 β) ≤ 𝓤 α
state_after: no goals
Theorem: SetLike.list_prod_ofFn_mem_graded
File: Mathlib/Algebra/GradedMonoid.lean

tactic: rw [List.ofFn_eq_map, List.ofFn_eq_map]
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n : ℕ
i : Fin n → ι
r : Fin n → R
h : ∀ (j : Fin n), r j ∈ A (i j)
⊢ (List.ofFn r).prod ∈ A (List.ofFn i).sum
state_after: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n : ℕ
i : Fin n → ι
r : Fin n → R
h : ∀ (j : Fin n), r j ∈ A (i j)
⊢ (List.map r (List.finRange n)).prod ∈ A (List.map i (List.finRange n)).sum

tactic: exact list_prod_map_mem_graded _ _ _ fun _ _ => h _
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n : ℕ
i : Fin n → ι
r : Fin n → R
h : ∀ (j : Fin n), r j ∈ A (i j)
⊢ (List.map r (List.finRange n)).prod ∈ A (List.map i (List.finRange n)).sum
state_after: no goals
Theorem: Int.lt_asymm
File: Mathlib/Data/Int/Defs.lean

tactic: rw [Int.not_lt]
state_before: a✝ b✝ c✝ d m n a b c : ℤ
⊢ a < b → ¬b < a
state_after: a✝ b✝ c✝ d m n a b c : ℤ
⊢ a < b → a ≤ b

tactic: exact Int.le_of_lt
state_before: a✝ b✝ c✝ d m n a b c : ℤ
⊢ a < b → a ≤ b
state_after: no goals
Theorem: FractionalIdeal.eq_spanSingleton_of_principal
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

tactic: rw [spanSingleton, ← coeToSubmodule_inj, coe_mk, span_singleton_generator]
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁶ : CommRing P
inst✝⁵ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝⁴ : CommRing R₁
K : Type u_4
inst✝³ : Field K
inst✝² : Algebra R₁ K
inst✝¹ : IsFractionRing R₁ K
I : FractionalIdeal S P
inst✝ : (↑I).IsPrincipal
⊢ I = spanSingleton S (generator ↑I)
state_after: no goals
Theorem: xor_not_left
File: Mathlib/Logic/Basic.lean

tactic: by_cases a <;> simp [*]
state_before: a b : Prop
⊢ Xor' (¬a) b ↔ (a ↔ b)
state_after: no goals
Theorem: Orientation.kahler_ne_zero
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

tactic: apply mt o.eq_zero_or_eq_zero_of_kahler_eq_zero
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
hx : x ≠ 0
hy : y ≠ 0
⊢ (o.kahler x) y ≠ 0
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
hx : x ≠ 0
hy : y ≠ 0
⊢ ¬(x = 0 ∨ y = 0)

tactic: tauto
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
hx : x ≠ 0
hy : y ≠ 0
⊢ ¬(x = 0 ∨ y = 0)
state_after: no goals
Theorem: Finset.mem_upShadow_iterate_iff_exists_mem_card_add
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

tactic: refine mem_upShadow_iterate_iff_exists_sdiff.trans <| exists_congr fun t ↦ and_congr_right fun _ ↦
  and_congr_right fun hst ↦ ?_
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ t ∈ ∂⁺ ^[k] 𝒜 ↔ ∃ s ∈ 𝒜, s ⊆ t ∧ t.card = s.card + k
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t✝ : Finset α
a : α
k r : ℕ
t : Finset α
x✝ : t ∈ 𝒜
hst : t ⊆ t✝
⊢ (t✝ \ t).card = k ↔ t✝.card = t.card + k

tactic: rw [card_sdiff hst, tsub_eq_iff_eq_add_of_le, add_comm]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t✝ : Finset α
a : α
k r : ℕ
t : Finset α
x✝ : t ∈ 𝒜
hst : t ⊆ t✝
⊢ (t✝ \ t).card = k ↔ t✝.card = t.card + k
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t✝ : Finset α
a : α
k r : ℕ
t : Finset α
x✝ : t ∈ 𝒜
hst : t ⊆ t✝
⊢ t.card ≤ t✝.card

tactic: exact card_mono hst
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t✝ : Finset α
a : α
k r : ℕ
t : Finset α
x✝ : t ∈ 𝒜
hst : t ⊆ t✝
⊢ t.card ≤ t✝.card
state_after: no goals
Theorem: SimpleGraph.TripartiteFromTriangles.Graph.in₀₁_iff'
File: Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean

tactic: rintro ⟨⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
⊢ (graph t).Adj (in₀ a) (in₁ b) → ∃ x ∈ t, x.1 = a ∧ x.2.1 = b
state_after: case in₀₁
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
c✝ : γ
a✝ : (a, b, c✝) ∈ t
⊢ ∃ x ∈ t, x.1 = a ∧ x.2.1 = b

tactic: exact ⟨_, ‹_›, by simp⟩
state_before: case in₀₁
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
c✝ : γ
a✝ : (a, b, c✝) ∈ t
⊢ ∃ x ∈ t, x.1 = a ∧ x.2.1 = b
state_after: no goals

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
c✝ : γ
a✝ : (a, b, c✝) ∈ t
⊢ (a, b, c✝).1 = a ∧ (a, b, c✝).2.1 = b
state_after: no goals

tactic: rintro ⟨⟨a, b, c⟩, h, rfl, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
⊢ (∃ x ∈ t, x.1 = a ∧ x.2.1 = b) → (graph t).Adj (in₀ a) (in₁ b)
state_after: case intro.mk.mk.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b' : β
c✝ c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ (graph t).Adj (in₀ (a, b, c).1) (in₁ (a, b, c).2.1)

tactic: constructor
state_before: case intro.mk.mk.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b' : β
c✝ c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ (graph t).Adj (in₀ (a, b, c).1) (in₁ (a, b, c).2.1)
state_after: case intro.mk.mk.intro.intro.a
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b' : β
c✝ c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ ((a, b, c).1, (a, b, c).2.1, ?intro.mk.mk.intro.intro.c) ∈ t

case intro.mk.mk.intro.intro.c
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b' : β
c✝ c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ γ

tactic: assumption
state_before: case intro.mk.mk.intro.intro.a
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b' : β
c✝ c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ ((a, b, c).1, (a, b, c).2.1, ?intro.mk.mk.intro.intro.c) ∈ t

case intro.mk.mk.intro.intro.c
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b' : β
c✝ c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ γ
state_after: no goals
Theorem: MeasureTheory.lintegral_finset_sum_measure
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [← Measure.sum_coe_finset, lintegral_sum_measure, ← Finset.tsum_subtype']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m✝ : MeasurableSpace α
μ✝ ν : Measure α
ι : Type u_5
m : MeasurableSpace α
s : Finset ι
f : α → ℝ≥0∞
μ : ι → Measure α
⊢ ∫⁻ (a : α), f a ∂∑ i ∈ s, μ i = ∑ i ∈ s, ∫⁻ (a : α), f a ∂μ i
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m✝ : MeasurableSpace α
μ✝ ν : Measure α
ι : Type u_5
m : MeasurableSpace α
s : Finset ι
f : α → ℝ≥0∞
μ : ι → Measure α
⊢ ∑' (i : { x // x ∈ s }), ∫⁻ (a : α), f a ∂μ ↑i = ∑' (x : ↑↑s), ∫⁻ (a : α), f a ∂μ ↑x

tactic: simp only [Finset.coe_sort_coe]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m✝ : MeasurableSpace α
μ✝ ν : Measure α
ι : Type u_5
m : MeasurableSpace α
s : Finset ι
f : α → ℝ≥0∞
μ : ι → Measure α
⊢ ∑' (i : { x // x ∈ s }), ∫⁻ (a : α), f a ∂μ ↑i = ∑' (x : ↑↑s), ∫⁻ (a : α), f a ∂μ ↑x
state_after: no goals
Theorem: continuous_finprod_cond
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: simp only [← finprod_subtype_eq_finprod_cond]
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → X → M
p : ι → Prop
hc : ∀ (i : ι), p i → Continuous (f i)
hf : LocallyFinite fun i => mulSupport (f i)
⊢ Continuous fun x => ∏ᶠ (i : ι) (_ : p i), f i x
state_after: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → X → M
p : ι → Prop
hc : ∀ (i : ι), p i → Continuous (f i)
hf : LocallyFinite fun i => mulSupport (f i)
⊢ Continuous fun x => ∏ᶠ (j : Subtype p), f (↑j) x

tactic: exact continuous_finprod (fun i => hc i i.2) (hf.comp_injective Subtype.coe_injective)
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → X → M
p : ι → Prop
hc : ∀ (i : ι), p i → Continuous (f i)
hf : LocallyFinite fun i => mulSupport (f i)
⊢ Continuous fun x => ∏ᶠ (j : Subtype p), f (↑j) x
state_after: no goals
Theorem: Nat.coprime_self_add_right
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [add_comm, coprime_add_self_right]
state_before: m n : ℕ
⊢ m.Coprime (m + n) ↔ m.Coprime n
state_after: no goals
Theorem: Matroid.not_finiteRk
File: Mathlib/Data/Matroid/Basic.lean

tactic: intro h
state_before: α : Type u_1
M✝ M : Matroid α
inst✝ : M.InfiniteRk
⊢ ¬M.FiniteRk
state_after: α : Type u_1
M✝ M : Matroid α
inst✝ : M.InfiniteRk
h : M.FiniteRk
⊢ False

tactic: obtain ⟨B,hB⟩ := M.exists_base
state_before: α : Type u_1
M✝ M : Matroid α
inst✝ : M.InfiniteRk
h : M.FiniteRk
⊢ False
state_after: case intro
α : Type u_1
M✝ M : Matroid α
inst✝ : M.InfiniteRk
h : M.FiniteRk
B : Set α
hB : M.Base B
⊢ False

tactic: exact hB.infinite hB.finite
state_before: case intro
α : Type u_1
M✝ M : Matroid α
inst✝ : M.InfiniteRk
h : M.FiniteRk
B : Set α
hB : M.Base B
⊢ False
state_after: no goals
Theorem: List.left_mem_of_mk_mem_sym2
File: Mathlib/Data/List/Sym.lean

tactic: exact (not_mem_nil _ h).elim
state_before: case nil
α : Type u_1
a b : α
h : s(a, b) ∈ [].sym2
⊢ a ∈ []
state_after: no goals

tactic: rw [mem_cons]
state_before: case cons
α : Type u_1
a b x : α
xs : List α
ih : s(a, b) ∈ xs.sym2 → a ∈ xs
h : s(a, b) ∈ (x :: xs).sym2
⊢ a ∈ x :: xs
state_after: case cons
α : Type u_1
a b x : α
xs : List α
ih : s(a, b) ∈ xs.sym2 → a ∈ xs
h : s(a, b) ∈ (x :: xs).sym2
⊢ a = x ∨ a ∈ xs

tactic: rw [mem_sym2_cons_iff] at h
state_before: case cons
α : Type u_1
a b x : α
xs : List α
ih : s(a, b) ∈ xs.sym2 → a ∈ xs
h : s(a, b) ∈ (x :: xs).sym2
⊢ a = x ∨ a ∈ xs
state_after: case cons
α : Type u_1
a b x : α
xs : List α
ih : s(a, b) ∈ xs.sym2 → a ∈ xs
h : s(a, b) = s(x, x) ∨ (∃ y ∈ xs, s(a, b) = s(x, y)) ∨ s(a, b) ∈ xs.sym2
⊢ a = x ∨ a ∈ xs

tactic: obtain (h | ⟨c, hc, h⟩ | h) := h
state_before: case cons
α : Type u_1
a b x : α
xs : List α
ih : s(a, b) ∈ xs.sym2 → a ∈ xs
h : s(a, b) = s(x, x) ∨ (∃ y ∈ xs, s(a, b) = s(x, y)) ∨ s(a, b) ∈ xs.sym2
⊢ a = x ∨ a ∈ xs
state_after: case cons.inl
α : Type u_1
a b x : α
xs : List α
ih : s(a, b) ∈ xs.sym2 → a ∈ xs
h : s(a, b) = s(x, x)
⊢ a = x ∨ a ∈ xs

case cons.inr.inl.intro.intro
α : Type u_1
a b x : α
xs : List α
ih : s(a, b) ∈ xs.sym2 → a ∈ xs
c : α
hc : c ∈ xs
h : s(a, b) = s(x, c)
⊢ a = x ∨ a ∈ xs

case cons.inr.inr
α : Type u_1
a b x : α
xs : List α
ih : s(a, b) ∈ xs.sym2 → a ∈ xs
h : s(a, b) ∈ xs.sym2
⊢ a = x ∨ a ∈ xs

tactic: rw [Sym2.eq_iff, ← and_or_left] at h
state_before: case cons.inl
α : Type u_1
a b x : α
xs : List α
ih : s(a, b) ∈ xs.sym2 → a ∈ xs
h : s(a, b) = s(x, x)
⊢ a = x ∨ a ∈ xs
state_after: case cons.inl
α : Type u_1
a b x : α
xs : List α
ih : s(a, b) ∈ xs.sym2 → a ∈ xs
h : a = x ∧ (b = x ∨ b = x)
⊢ a = x ∨ a ∈ xs

tactic: exact .inl h.1
state_before: case cons.inl
α : Type u_1
a b x : α
xs : List α
ih : s(a, b) ∈ xs.sym2 → a ∈ xs
h : a = x ∧ (b = x ∨ b = x)
⊢ a = x ∨ a ∈ xs
state_after: no goals

tactic: rw [Sym2.eq_iff] at h
state_before: case cons.inr.inl.intro.intro
α : Type u_1
a b x : α
xs : List α
ih : s(a, b) ∈ xs.sym2 → a ∈ xs
c : α
hc : c ∈ xs
h : s(a, b) = s(x, c)
⊢ a = x ∨ a ∈ xs
state_after: case cons.inr.inl.intro.intro
α : Type u_1
a b x : α
xs : List α
ih : s(a, b) ∈ xs.sym2 → a ∈ xs
c : α
hc : c ∈ xs
h : a = x ∧ b = c ∨ a = c ∧ b = x
⊢ a = x ∨ a ∈ xs

tactic: obtain (⟨rfl, rfl⟩ | ⟨rfl, rfl⟩) := h <;> simp [hc]
state_before: case cons.inr.inl.intro.intro
α : Type u_1
a b x : α
xs : List α
ih : s(a, b) ∈ xs.sym2 → a ∈ xs
c : α
hc : c ∈ xs
h : a = x ∧ b = c ∨ a = c ∧ b = x
⊢ a = x ∨ a ∈ xs
state_after: no goals

tactic: exact .inr <| ih h
state_before: case cons.inr.inr
α : Type u_1
a b x : α
xs : List α
ih : s(a, b) ∈ xs.sym2 → a ∈ xs
h : s(a, b) ∈ xs.sym2
⊢ a = x ∨ a ∈ xs
state_after: no goals
Theorem: SzemerediRegularity.stepBound_pos_iff
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean

tactic: positivity
state_before: n : ℕ
⊢ 0 < 4 ^ n
state_after: no goals
Theorem: Lagrange.basis_ne_zero
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simp_rw [Lagrange.basis, prod_ne_zero_iff, Ne, mem_erase]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hvs : Set.InjOn v ↑s
hi : i ∈ s
⊢ Lagrange.basis s v i ≠ 0
state_after: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hvs : Set.InjOn v ↑s
hi : i ∈ s
⊢ ∀ (a : ι), a ≠ i ∧ a ∈ s → ¬basisDivisor (v i) (v a) = 0

tactic: rintro j ⟨hij, hj⟩
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hvs : Set.InjOn v ↑s
hi : i ∈ s
⊢ ∀ (a : ι), a ≠ i ∧ a ∈ s → ¬basisDivisor (v i) (v a) = 0
state_after: case intro
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j✝ : ι
hvs : Set.InjOn v ↑s
hi : i ∈ s
j : ι
hij : j ≠ i
hj : j ∈ s
⊢ ¬basisDivisor (v i) (v j) = 0

tactic: rw [basisDivisor_eq_zero_iff, hvs.eq_iff hi hj]
state_before: case intro
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j✝ : ι
hvs : Set.InjOn v ↑s
hi : i ∈ s
j : ι
hij : j ≠ i
hj : j ∈ s
⊢ ¬basisDivisor (v i) (v j) = 0
state_after: case intro
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j✝ : ι
hvs : Set.InjOn v ↑s
hi : i ∈ s
j : ι
hij : j ≠ i
hj : j ∈ s
⊢ ¬i = j

tactic: exact hij.symm
state_before: case intro
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j✝ : ι
hvs : Set.InjOn v ↑s
hi : i ∈ s
j : ι
hij : j ≠ i
hj : j ∈ s
⊢ ¬i = j
state_after: no goals
Theorem: LSeries.term_sub_apply
File: Mathlib/NumberTheory/LSeries/Linearity.lean

tactic: rw [term_sub, Pi.sub_apply]
state_before: f g : ℕ → ℂ
s : ℂ
n : ℕ
⊢ term (f - g) s n = term f s n - term g s n
state_after: no goals
Theorem: Equiv.Perm.toList_nthLe_zero
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: simp [toList]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
h : x ∈ p.support
⊢ (p.toList x).nthLe 0 ⋯ = x
state_after: no goals
Theorem: Relation.reflTransGen_iff_eq
File: Mathlib/Logic/Relation.lean

tactic: rw [cases_head_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : ∀ (b : α), ¬r a b
⊢ ReflTransGen r a b ↔ b = a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : ∀ (b : α), ¬r a b
⊢ (a = b ∨ ∃ c, r a c ∧ ReflTransGen r c b) ↔ b = a

tactic: simp [h, eq_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : ∀ (b : α), ¬r a b
⊢ (a = b ∨ ∃ c, r a c ∧ ReflTransGen r c b) ↔ b = a
state_after: no goals
Theorem: Real.sqrt_eq_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: obtain h | h := le_or_lt 0 x
state_before: z x✝ y x : ℝ
⊢ √x = x ^ (1 / 2)
state_after: case inl
z x✝ y x : ℝ
h : 0 ≤ x
⊢ √x = x ^ (1 / 2)

case inr
z x✝ y x : ℝ
h : x < 0
⊢ √x = x ^ (1 / 2)

tactic: rw [← mul_self_inj_of_nonneg (sqrt_nonneg _) (rpow_nonneg h _), mul_self_sqrt h, ← sq,
  ← rpow_natCast, ← rpow_mul h]
state_before: case inl
z x✝ y x : ℝ
h : 0 ≤ x
⊢ √x = x ^ (1 / 2)
state_after: case inl
z x✝ y x : ℝ
h : 0 ≤ x
⊢ x = x ^ (1 / 2 * ↑2)

tactic: norm_num
state_before: case inl
z x✝ y x : ℝ
h : 0 ≤ x
⊢ x = x ^ (1 / 2 * ↑2)
state_after: no goals

tactic: have : 1 / (2 : ℝ) * π = π / (2 : ℝ) := by ring
state_before: case inr
z x✝ y x : ℝ
h : x < 0
⊢ √x = x ^ (1 / 2)
state_after: case inr
z x✝ y x : ℝ
h : x < 0
this : 1 / 2 * π = π / 2
⊢ √x = x ^ (1 / 2)

tactic: rw [sqrt_eq_zero_of_nonpos h.le, rpow_def_of_neg h, this, cos_pi_div_two, mul_zero]
state_before: case inr
z x✝ y x : ℝ
h : x < 0
this : 1 / 2 * π = π / 2
⊢ √x = x ^ (1 / 2)
state_after: no goals

tactic: ring
state_before: z x✝ y x : ℝ
h : x < 0
⊢ 1 / 2 * π = π / 2
state_after: no goals
Theorem: Polynomial.hasStrictDerivAt
File: Mathlib/Analysis/Calculus/Deriv/Polynomial.lean

tactic: induction p using Polynomial.induction_on' with
| h_add p q hp hq => simpa using hp.add hq
| h_monomial n a => simpa [mul_assoc] using (hasStrictDerivAt_pow n x).const_mul a
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 𝕜
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Algebra R 𝕜
p : 𝕜[X]
q : R[X]
x : 𝕜
⊢ HasStrictDerivAt (fun x => eval x p) (eval x (derivative p)) x
state_after: no goals

tactic: simpa using hp.add hq
state_before: case h_add
𝕜 : 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 𝕜
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Algebra R 𝕜
p✝ : 𝕜[X]
q✝ : R[X]
x : 𝕜
p q : 𝕜[X]
hp : HasStrictDerivAt (fun x => eval x p) (eval x (derivative p)) x
hq : HasStrictDerivAt (fun x => eval x q) (eval x (derivative q)) x
⊢ HasStrictDerivAt (fun x => eval x (p + q)) (eval x (derivative (p + q))) x
state_after: no goals

tactic: simpa [mul_assoc] using (hasStrictDerivAt_pow n x).const_mul a
state_before: case h_monomial
𝕜 : 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 𝕜
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Algebra R 𝕜
p : 𝕜[X]
q : R[X]
x : 𝕜
n : ℕ
a : 𝕜
⊢ HasStrictDerivAt (fun x => eval x ((monomial n) a)) (eval x (derivative ((monomial n) a))) x
state_after: no goals
Theorem: CategoryTheory.initiallySmall_iff_exists_small_weakly_initial_set
File: Mathlib/CategoryTheory/Limits/FinallySmall.lean

tactic: refine ⟨fun _ => InitiallySmall.exists_small_weakly_initial_set _, fun h => ?_⟩
state_before: J : Type u
inst✝¹ : Category.{v, u} J
inst✝ : IsCofilteredOrEmpty J
⊢ InitiallySmall J ↔ ∃ s, ∃ (_ : Small.{v, u} ↑s), ∀ (i : J), ∃ j ∈ s, Nonempty (j ⟶ i)
state_after: J : Type u
inst✝¹ : Category.{v, u} J
inst✝ : IsCofilteredOrEmpty J
h : ∃ s, ∃ (_ : Small.{v, u} ↑s), ∀ (i : J), ∃ j ∈ s, Nonempty (j ⟶ i)
⊢ InitiallySmall J

tactic: rcases h with ⟨s, hs, hs'⟩
state_before: J : Type u
inst✝¹ : Category.{v, u} J
inst✝ : IsCofilteredOrEmpty J
h : ∃ s, ∃ (_ : Small.{v, u} ↑s), ∀ (i : J), ∃ j ∈ s, Nonempty (j ⟶ i)
⊢ InitiallySmall J
state_after: case intro.intro
J : Type u
inst✝¹ : Category.{v, u} J
inst✝ : IsCofilteredOrEmpty J
s : Set J
hs : Small.{v, u} ↑s
hs' : ∀ (i : J), ∃ j ∈ s, Nonempty (j ⟶ i)
⊢ InitiallySmall J

tactic: exact initiallySmall_of_small_weakly_initial_set s hs'
state_before: case intro.intro
J : Type u
inst✝¹ : Category.{v, u} J
inst✝ : IsCofilteredOrEmpty J
s : Set J
hs : Small.{v, u} ↑s
hs' : ∀ (i : J), ∃ j ∈ s, Nonempty (j ⟶ i)
⊢ InitiallySmall J
state_after: no goals
Theorem: StrictMonoOn.eq_iff_eq
File: Mathlib/Order/Monotone/Basic.lean

tactic: rintro rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : LinearOrder α
inst✝ : Preorder β
f : α → β
s : Set α
hf : StrictMonoOn f s
a b : α
ha : a ∈ s
hb : b ∈ s
⊢ a = b → f a = f b
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : LinearOrder α
inst✝ : Preorder β
f : α → β
s : Set α
hf : StrictMonoOn f s
a : α
ha hb : a ∈ s
⊢ f a = f a

tactic: rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : LinearOrder α
inst✝ : Preorder β
f : α → β
s : Set α
hf : StrictMonoOn f s
a : α
ha hb : a ∈ s
⊢ f a = f a
state_after: no goals
Theorem: MeasureTheory.Lp.dist_def
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: simp_rw [dist, norm_def]
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 g : ↥(Lp E p μ)
⊢ dist f g = (snorm (↑↑f - ↑↑g) p μ).toReal
state_after: α : 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 g : ↥(Lp E p μ)
⊢ (snorm (↑↑(f - g)) p μ).toReal = (snorm (↑↑f - ↑↑g) p μ).toReal

tactic: refine congr_arg _ ?_
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 g : ↥(Lp E p μ)
⊢ (snorm (↑↑(f - g)) p μ).toReal = (snorm (↑↑f - ↑↑g) p μ).toReal
state_after: α : 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 g : ↥(Lp E p μ)
⊢ snorm (↑↑(f - g)) p μ = snorm (↑↑f - ↑↑g) p μ

tactic: apply snorm_congr_ae (coeFn_sub _ _)
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 g : ↥(Lp E p μ)
⊢ snorm (↑↑(f - g)) p μ = snorm (↑↑f - ↑↑g) p μ
state_after: no goals
Theorem: pow_inj_iff_of_orderOf_eq_zero
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [pow_eq_pow_iff_modEq, h, modEq_zero_iff]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m✝ n✝ : ℕ
h : orderOf x = 0
n m : ℕ
⊢ x ^ n = x ^ m ↔ n = m
state_after: no goals
Theorem: Fin.rev_lt_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [← rev_lt_rev, rev_rev]
state_before: n m : ℕ
i j : Fin n
⊢ i.rev < j ↔ j.rev < i
state_after: no goals