1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Derivation.leibniz_of_mul_eq_one
File: Mathlib/RingTheory/Derivation/Basic.lean

tactic: rw [neg_smul]
state_before: R : Type u_1
inst✝⁵ : CommRing R
A : Type u_2
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
M : Type u_3
inst✝² : AddCommGroup M
inst✝¹ : Module A M
inst✝ : Module R M
D D1 D2 : Derivation R A M
r : R
a✝ b✝ a b : A
h : a * b = 1
⊢ D a = -a ^ 2 • D b
state_after: R : Type u_1
inst✝⁵ : CommRing R
A : Type u_2
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
M : Type u_3
inst✝² : AddCommGroup M
inst✝¹ : Module A M
inst✝ : Module R M
D D1 D2 : Derivation R A M
r : R
a✝ b✝ a b : A
h : a * b = 1
⊢ D a = -(a ^ 2 • D b)

tactic: refine eq_neg_of_add_eq_zero_left ?_
state_before: R : Type u_1
inst✝⁵ : CommRing R
A : Type u_2
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
M : Type u_3
inst✝² : AddCommGroup M
inst✝¹ : Module A M
inst✝ : Module R M
D D1 D2 : Derivation R A M
r : R
a✝ b✝ a b : A
h : a * b = 1
⊢ D a = -(a ^ 2 • D b)
state_after: R : Type u_1
inst✝⁵ : CommRing R
A : Type u_2
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
M : Type u_3
inst✝² : AddCommGroup M
inst✝¹ : Module A M
inst✝ : Module R M
D D1 D2 : Derivation R A M
r : R
a✝ b✝ a b : A
h : a * b = 1
⊢ D a + a ^ 2 • D b = 0

tactic: calc
  D a + a ^ 2 • D b = a • b • D a + a • a • D b := by simp only [smul_smul, h, one_smul, sq]
  _ = a • D (a * b) := by rw [leibniz, smul_add, add_comm]
  _ = 0 := by rw [h, map_one_eq_zero, smul_zero]
state_before: R : Type u_1
inst✝⁵ : CommRing R
A : Type u_2
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
M : Type u_3
inst✝² : AddCommGroup M
inst✝¹ : Module A M
inst✝ : Module R M
D D1 D2 : Derivation R A M
r : R
a✝ b✝ a b : A
h : a * b = 1
⊢ D a + a ^ 2 • D b = 0
state_after: no goals

tactic: simp only [smul_smul, h, one_smul, sq]
state_before: R : Type u_1
inst✝⁵ : CommRing R
A : Type u_2
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
M : Type u_3
inst✝² : AddCommGroup M
inst✝¹ : Module A M
inst✝ : Module R M
D D1 D2 : Derivation R A M
r : R
a✝ b✝ a b : A
h : a * b = 1
⊢ D a + a ^ 2 • D b = a • b • D a + a • a • D b
state_after: no goals

tactic: rw [leibniz, smul_add, add_comm]
state_before: R : Type u_1
inst✝⁵ : CommRing R
A : Type u_2
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
M : Type u_3
inst✝² : AddCommGroup M
inst✝¹ : Module A M
inst✝ : Module R M
D D1 D2 : Derivation R A M
r : R
a✝ b✝ a b : A
h : a * b = 1
⊢ a • b • D a + a • a • D b = a • D (a * b)
state_after: no goals

tactic: rw [h, map_one_eq_zero, smul_zero]
state_before: R : Type u_1
inst✝⁵ : CommRing R
A : Type u_2
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
M : Type u_3
inst✝² : AddCommGroup M
inst✝¹ : Module A M
inst✝ : Module R M
D D1 D2 : Derivation R A M
r : R
a✝ b✝ a b : A
h : a * b = 1
⊢ a • D (a * b) = 0
state_after: no goals
Theorem: Polynomial.eval₂_at_one
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: convert eval₂_at_apply (p := p) f 1
state_before: R : Type u
S✝ : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
x : R
S : Type u_1
inst✝ : Semiring S
f : R →+* S
⊢ eval₂ f 1 p = f (eval 1 p)
state_after: case h.e'_2.h.e'_6
R : Type u
S✝ : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
x : R
S : Type u_1
inst✝ : Semiring S
f : R →+* S
⊢ 1 = f 1

tactic: simp
state_before: case h.e'_2.h.e'_6
R : Type u
S✝ : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
x : R
S : Type u_1
inst✝ : Semiring S
f : R →+* S
⊢ 1 = f 1
state_after: no goals
Theorem: Affine.Simplex.span_eq_top
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: rw [AffineIndependent.affineSpan_eq_top_iff_card_eq_finrank_add_one T.independent,
  Fintype.card_fin, hrank]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : FiniteDimensional k V
n : ℕ
T : Simplex k V n
hrank : finrank k V = n
⊢ affineSpan k (Set.range T.points) = ⊤
state_after: no goals
Theorem: Complex.IsExpCmpFilter.isTheta_cpow_exp_re_mul_log
File: Mathlib/Analysis/SpecialFunctions/CompareExp.lean

tactic: simp only [Real.rpow_def_of_pos, abs.pos hz, mul_comm]
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
a z : ℂ
hz : z ≠ 0
⊢ (fun z => abs z ^ a.re) z = (fun z => Real.exp (a.re * Real.log (abs z))) z
state_after: no goals
Theorem: Monoid.CoprodI.iSup_mrange_of
File: Mathlib/GroupTheory/CoprodI.lean

tactic: simp [← mrange_eq_iSup]
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
⊢ ⨆ i, MonoidHom.mrange of = ⊤
state_after: no goals
Theorem: CliffordAlgebraComplex.toComplex_involute
File: Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean

tactic: have : toComplex (involute (ι Q 1)) = conj (toComplex (ι Q 1)) := by
  simp only [involute_ι, toComplex_ι, AlgHom.map_neg, one_smul, Complex.conj_I]
state_before: c : CliffordAlgebra Q
⊢ toComplex (involute c) = (starRingEnd ℂ) (toComplex c)
state_after: c : CliffordAlgebra Q
this : toComplex (involute ((ι Q) 1)) = (starRingEnd ℂ) (toComplex ((ι Q) 1))
⊢ toComplex (involute c) = (starRingEnd ℂ) (toComplex c)

tactic: suffices toComplex.comp involute = Complex.conjAe.toAlgHom.comp toComplex by
  exact AlgHom.congr_fun this c
state_before: c : CliffordAlgebra Q
this : toComplex (involute ((ι Q) 1)) = (starRingEnd ℂ) (toComplex ((ι Q) 1))
⊢ toComplex (involute c) = (starRingEnd ℂ) (toComplex c)
state_after: c : CliffordAlgebra Q
this : toComplex (involute ((ι Q) 1)) = (starRingEnd ℂ) (toComplex ((ι Q) 1))
⊢ toComplex.comp involute = (↑Complex.conjAe).comp toComplex

tactic: ext : 2
state_before: c : CliffordAlgebra Q
this : toComplex (involute ((ι Q) 1)) = (starRingEnd ℂ) (toComplex ((ι Q) 1))
⊢ toComplex.comp involute = (↑Complex.conjAe).comp toComplex
state_after: case a.h
c : CliffordAlgebra Q
this : toComplex (involute ((ι Q) 1)) = (starRingEnd ℂ) (toComplex ((ι Q) 1))
⊢ ((toComplex.comp involute).toLinearMap ∘ₗ ι Q) 1 = (((↑Complex.conjAe).comp toComplex).toLinearMap ∘ₗ ι Q) 1

tactic: exact this
state_before: case a.h
c : CliffordAlgebra Q
this : toComplex (involute ((ι Q) 1)) = (starRingEnd ℂ) (toComplex ((ι Q) 1))
⊢ ((toComplex.comp involute).toLinearMap ∘ₗ ι Q) 1 = (((↑Complex.conjAe).comp toComplex).toLinearMap ∘ₗ ι Q) 1
state_after: no goals

tactic: simp only [involute_ι, toComplex_ι, AlgHom.map_neg, one_smul, Complex.conj_I]
state_before: c : CliffordAlgebra Q
⊢ toComplex (involute ((ι Q) 1)) = (starRingEnd ℂ) (toComplex ((ι Q) 1))
state_after: no goals

tactic: exact AlgHom.congr_fun this c
state_before: c : CliffordAlgebra Q
this✝ : toComplex (involute ((ι Q) 1)) = (starRingEnd ℂ) (toComplex ((ι Q) 1))
this : toComplex.comp involute = (↑Complex.conjAe).comp toComplex
⊢ toComplex (involute c) = (starRingEnd ℂ) (toComplex c)
state_after: no goals
Theorem: Multiset.disjoint_add_left
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [Disjoint, or_imp, forall_and]
state_before: α : Type u_1
β : Type v
γ : Type u_2
s t u : Multiset α
⊢ (s + t).Disjoint u ↔ s.Disjoint u ∧ t.Disjoint u
state_after: no goals
Theorem: Finset.card_eq_sum_card_fiberwise
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: simp only [card_eq_sum_ones, sum_fiberwise_of_maps_to H]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : DecidableEq β
f : α → β
s : Finset α
t : Finset β
H : ∀ x ∈ s, f x ∈ t
⊢ s.card = ∑ a ∈ t, (filter (fun x => f x = a) s).card
state_after: no goals
Theorem: ArithmeticFunction.pmul_zeta
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: ext x
state_before: R : Type u_1
inst✝ : NonAssocSemiring R
f : ArithmeticFunction R
⊢ f.pmul ↑ζ = f
state_after: case h
R : Type u_1
inst✝ : NonAssocSemiring R
f : ArithmeticFunction R
x : ℕ
⊢ (f.pmul ↑ζ) x = f x

tactic: cases x <;> simp [Nat.succ_ne_zero]
state_before: case h
R : Type u_1
inst✝ : NonAssocSemiring R
f : ArithmeticFunction R
x : ℕ
⊢ (f.pmul ↑ζ) x = f x
state_after: no goals
Theorem: Option.orElse_eq_some
File: Mathlib/Data/Option/Basic.lean

tactic: cases o
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
o o' : Option α
x : α
⊢ (HOrElse.hOrElse o fun x => o') = some x ↔ o = some x ∨ o = none ∧ o' = some x
state_after: case none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
o' : Option α
x : α
⊢ (HOrElse.hOrElse none fun x => o') = some x ↔ none = some x ∨ none = none ∧ o' = some x

case some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
o' : Option α
x val✝ : α
⊢ (HOrElse.hOrElse (some val✝) fun x => o') = some x ↔ some val✝ = some x ∨ some val✝ = none ∧ o' = some x

tactic: simp only [true_and, false_or, eq_self_iff_true, none_orElse]
state_before: case none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
o' : Option α
x : α
⊢ (HOrElse.hOrElse none fun x => o') = some x ↔ none = some x ∨ none = none ∧ o' = some x
state_after: no goals

tactic: simp only [some_orElse, or_false, false_and]
state_before: case some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
o' : Option α
x val✝ : α
⊢ (HOrElse.hOrElse (some val✝) fun x => o') = some x ↔ some val✝ = some x ∨ some val✝ = none ∧ o' = some x
state_after: no goals
Theorem: cycleType_finRotate
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: rw [isCycle_finRotate.cycleType, support_finRotate, ← Fintype.card, Fintype.card_fin]
state_before: n : ℕ
⊢ (finRotate (n + 2)).cycleType = {n + 2}
state_after: n : ℕ
⊢ ↑[n + 2] = {n + 2}

tactic: rfl
state_before: n : ℕ
⊢ ↑[n + 2] = {n + 2}
state_after: no goals
Theorem: Polynomial.eraseLead_coeff_of_ne
File: Mathlib/Algebra/Polynomial/EraseLead.lean

tactic: simp [eraseLead_coeff, hi]
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
i : ℕ
hi : i ≠ f.natDegree
⊢ f.eraseLead.coeff i = f.coeff i
state_after: no goals
Theorem: List.mem_foldr_permutationsAux2
File: Mathlib/Data/List/Permutation.lean

tactic: have :
  (∃ a : List α,
      a ∈ L ∧ ∃ l₁ l₂ : List α, ¬l₂ = nil ∧ a = l₁ ++ l₂ ∧ l' = l₁ ++ t :: (l₂ ++ ts)) ↔
    ∃ l₁ l₂ : List α, ¬l₂ = nil ∧ l₁ ++ l₂ ∈ L ∧ l' = l₁ ++ t :: (l₂ ++ ts) :=
  ⟨fun ⟨_, aL, l₁, l₂, l0, e, h⟩ => ⟨l₁, l₂, l0, e ▸ aL, h⟩, fun ⟨l₁, l₂, l0, aL, h⟩ =>
    ⟨_, aL, l₁, l₂, l0, rfl, h⟩⟩
state_before: α : Type u_1
β : Type u_2
t : α
ts : List α
r L : List (List α)
l' : List α
⊢ l' ∈ foldr (fun y r => (permutationsAux2 t ts r y id).2) r L ↔
    l' ∈ r ∨ ∃ l₁ l₂, l₁ ++ l₂ ∈ L ∧ l₂ ≠ [] ∧ l' = l₁ ++ t :: l₂ ++ ts
state_after: α : Type u_1
β : Type u_2
t : α
ts : List α
r L : List (List α)
l' : List α
this :
  (∃ a, a ∈ L ∧ ∃ l₁ l₂, ¬l₂ = [] ∧ a = l₁ ++ l₂ ∧ l' = l₁ ++ t :: (l₂ ++ ts)) ↔
    ∃ l₁ l₂, ¬l₂ = [] ∧ l₁ ++ l₂ ∈ L ∧ l' = l₁ ++ t :: (l₂ ++ ts)
⊢ l' ∈ foldr (fun y r => (permutationsAux2 t ts r y id).2) r L ↔
    l' ∈ r ∨ ∃ l₁ l₂, l₁ ++ l₂ ∈ L ∧ l₂ ≠ [] ∧ l' = l₁ ++ t :: l₂ ++ ts

tactic: rw [foldr_permutationsAux2]
state_before: α : Type u_1
β : Type u_2
t : α
ts : List α
r L : List (List α)
l' : List α
this :
  (∃ a, a ∈ L ∧ ∃ l₁ l₂, ¬l₂ = [] ∧ a = l₁ ++ l₂ ∧ l' = l₁ ++ t :: (l₂ ++ ts)) ↔
    ∃ l₁ l₂, ¬l₂ = [] ∧ l₁ ++ l₂ ∈ L ∧ l' = l₁ ++ t :: (l₂ ++ ts)
⊢ l' ∈ foldr (fun y r => (permutationsAux2 t ts r y id).2) r L ↔
    l' ∈ r ∨ ∃ l₁ l₂, l₁ ++ l₂ ∈ L ∧ l₂ ≠ [] ∧ l' = l₁ ++ t :: l₂ ++ ts
state_after: α : Type u_1
β : Type u_2
t : α
ts : List α
r L : List (List α)
l' : List α
this :
  (∃ a, a ∈ L ∧ ∃ l₁ l₂, ¬l₂ = [] ∧ a = l₁ ++ l₂ ∧ l' = l₁ ++ t :: (l₂ ++ ts)) ↔
    ∃ l₁ l₂, ¬l₂ = [] ∧ l₁ ++ l₂ ∈ L ∧ l' = l₁ ++ t :: (l₂ ++ ts)
⊢ l' ∈ (L.bind fun y => (permutationsAux2 t ts [] y id).2) ++ r ↔
    l' ∈ r ∨ ∃ l₁ l₂, l₁ ++ l₂ ∈ L ∧ l₂ ≠ [] ∧ l' = l₁ ++ t :: l₂ ++ ts

tactic: simp only [mem_permutationsAux2', ← this, or_comm, and_left_comm, mem_append, mem_bind,
  append_assoc, cons_append, exists_prop]
state_before: α : Type u_1
β : Type u_2
t : α
ts : List α
r L : List (List α)
l' : List α
this :
  (∃ a, a ∈ L ∧ ∃ l₁ l₂, ¬l₂ = [] ∧ a = l₁ ++ l₂ ∧ l' = l₁ ++ t :: (l₂ ++ ts)) ↔
    ∃ l₁ l₂, ¬l₂ = [] ∧ l₁ ++ l₂ ∈ L ∧ l' = l₁ ++ t :: (l₂ ++ ts)
⊢ l' ∈ (L.bind fun y => (permutationsAux2 t ts [] y id).2) ++ r ↔
    l' ∈ r ∨ ∃ l₁ l₂, l₁ ++ l₂ ∈ L ∧ l₂ ≠ [] ∧ l' = l₁ ++ t :: l₂ ++ ts
state_after: no goals
Theorem: Multiset.exists_mem_of_ne_zero
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type v
γ : Type u_2
s : Multiset α
l✝ : List α
hl : Quot.mk Setoid.r l✝ ≠ 0
a : α
l : List α
x✝ : Quot.mk Setoid.r (a :: l) ≠ 0
⊢ a ∈ Quot.mk Setoid.r (a :: l)
state_after: no goals
Theorem: Polynomial.map_mapRingHom_eval_map
File: Mathlib/Algebra/Polynomial/Bivariate.lean

tactic: rw [eval_map, ← coe_mapRingHom, eval₂_hom]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
p : R[X][Y]
q : R[X]
⊢ eval (map f q) (map (mapRingHom f) p) = map f (eval q p)
state_after: no goals
Theorem: LocallyLipschitz.continuous
File: Mathlib/Topology/EMetricSpace/Lipschitz.lean

tactic: rw [continuous_iff_continuousAt]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f✝ f : α → β
hf : LocallyLipschitz f
⊢ Continuous f
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f✝ f : α → β
hf : LocallyLipschitz f
⊢ ∀ (x : α), ContinuousAt f x

tactic: intro x
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f✝ f : α → β
hf : LocallyLipschitz f
⊢ ∀ (x : α), ContinuousAt f x
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f✝ f : α → β
hf : LocallyLipschitz f
x : α
⊢ ContinuousAt f x

tactic: rcases (hf x) with ⟨K, t, ht, hK⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f✝ f : α → β
hf : LocallyLipschitz f
x : α
⊢ ContinuousAt f x
state_after: case intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f✝ f : α → β
hf : LocallyLipschitz f
x : α
K : ℝ≥0
t : Set α
ht : t ∈ 𝓝 x
hK : LipschitzOnWith K f t
⊢ ContinuousAt f x

tactic: exact (hK.continuousOn).continuousAt ht
state_before: case intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f✝ f : α → β
hf : LocallyLipschitz f
x : α
K : ℝ≥0
t : Set α
ht : t ∈ 𝓝 x
hK : LipschitzOnWith K f t
⊢ ContinuousAt f x
state_after: no goals
Theorem: CategoryTheory.GradedObject.single_map_singleObjApplyIsoOfEq_hom
File: Mathlib/CategoryTheory/GradedObject/Single.lean

tactic: subst h
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{u_3, u_2} C
inst✝¹ : HasInitial C
inst✝ : DecidableEq J
j : J
X Y : C
f : X ⟶ Y
i : J
h : i = j
⊢ (single j).map f i ≫ (singleObjApplyIsoOfEq j Y i h).hom = (singleObjApplyIsoOfEq j X i h).hom ≫ f
state_after: J : Type u_1
C : Type u_2
inst✝² : Category.{u_3, u_2} C
inst✝¹ : HasInitial C
inst✝ : DecidableEq J
X Y : C
f : X ⟶ Y
i : J
⊢ (single i).map f i ≫ (singleObjApplyIsoOfEq i Y i ⋯).hom = (singleObjApplyIsoOfEq i X i ⋯).hom ≫ f

tactic: simp [singleObjApplyIsoOfEq, single]
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{u_3, u_2} C
inst✝¹ : HasInitial C
inst✝ : DecidableEq J
X Y : C
f : X ⟶ Y
i : J
⊢ (single i).map f i ≫ (singleObjApplyIsoOfEq i Y i ⋯).hom = (singleObjApplyIsoOfEq i X i ⋯).hom ≫ f
state_after: no goals
Theorem: Filter.NeBot.eq_pure_iff
File: Mathlib/Order/Filter/Ultrafilter.lean

tactic: rw [← hf.le_pure_iff, le_pure_iff]
state_before: α : Type u
β : Type v
γ : Type u_1
f : Filter α
s : Set α
a : α
hf : f.NeBot
x : α
⊢ f = pure x ↔ {x} ∈ f
state_after: no goals
Theorem: Stream'.Seq.head_dropn
File: Mathlib/Data/Seq/Seq.lean

tactic: induction' n with n IH generalizing s
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ (s.drop n).head = s.get? n
state_after: case zero
α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ (s.drop 0).head = s.get? 0

case succ
α : Type u
β : Type v
γ : Type w
n : ℕ
IH : ∀ (s : Seq α), (s.drop n).head = s.get? n
s : Seq α
⊢ (s.drop (n + 1)).head = s.get? (n + 1)

tactic: rw [← get?_tail, ← dropn_tail]
state_before: case succ
α : Type u
β : Type v
γ : Type w
n : ℕ
IH : ∀ (s : Seq α), (s.drop n).head = s.get? n
s : Seq α
⊢ (s.drop (n + 1)).head = s.get? (n + 1)
state_after: case succ
α : Type u
β : Type v
γ : Type w
n : ℕ
IH : ∀ (s : Seq α), (s.drop n).head = s.get? n
s : Seq α
⊢ (s.tail.drop n).head = s.tail.get? n

tactic: apply IH
state_before: case succ
α : Type u
β : Type v
γ : Type w
n : ℕ
IH : ∀ (s : Seq α), (s.drop n).head = s.get? n
s : Seq α
⊢ (s.tail.drop n).head = s.tail.get? n
state_after: no goals

tactic: rfl
state_before: case zero
α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ (s.drop 0).head = s.get? 0
state_after: no goals
Theorem: CategoryTheory.braiding_inv_tensorUnit_right
File: Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean

tactic: rw [Iso.inv_ext]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ (β_ X (𝟙_ C)).inv = (λ_ X).hom ≫ (ρ_ X).inv
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ (β_ X (𝟙_ C)).hom ≫ (λ_ X).hom ≫ (ρ_ X).inv = 𝟙 (X ⊗ 𝟙_ C)

tactic: rw [braiding_tensorUnit_right]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ (β_ X (𝟙_ C)).hom ≫ (λ_ X).hom ≫ (ρ_ X).inv = 𝟙 (X ⊗ 𝟙_ C)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ ((ρ_ X).hom ≫ (λ_ X).inv) ≫ (λ_ X).hom ≫ (ρ_ X).inv = 𝟙 (X ⊗ 𝟙_ C)

tactic: coherence
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ ((ρ_ X).hom ≫ (λ_ X).inv) ≫ (λ_ X).hom ≫ (ρ_ X).inv = 𝟙 (X ⊗ 𝟙_ C)
state_after: no goals
Theorem: AffineSubspace.mem_perpBisector_iff_dist_eq
File: Mathlib/Geometry/Euclidean/PerpBisector.lean

tactic: rw [dist_eq_norm_vsub V, dist_eq_norm_vsub V, ← real_inner_add_sub_eq_zero_iff,
  vsub_sub_vsub_cancel_left, inner_add_left, add_eq_zero_iff_eq_neg, ← inner_neg_right,
  neg_vsub_eq_vsub_rev, mem_perpBisector_iff_inner_eq_inner]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c c₁ c₂ p₁ p₂ : P
⊢ c ∈ perpBisector p₁ p₂ ↔ dist c p₁ = dist c p₂
state_after: no goals
Theorem: Fintype.card_finset_len
File: Mathlib/Data/Fintype/Powerset.lean

tactic: simp [Fintype.subtype_card, Finset.card_univ]
state_before: α : Type u_1
inst✝ : Fintype α
k : ℕ
⊢ card { s // s.card = k } = (card α).choose k
state_after: no goals
Theorem: quadraticChar_eq_neg_one_iff_not_one
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/Basic.lean

tactic: rw [h]
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : a ≠ 0
h : (quadraticChar F) a = -1
⊢ ¬(quadraticChar F) a = 1
state_after: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : a ≠ 0
h : (quadraticChar F) a = -1
⊢ ¬-1 = 1

tactic: omega
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : a ≠ 0
h : (quadraticChar F) a = -1
⊢ ¬-1 = 1
state_after: no goals
Theorem: iUnion_Iio_eq_univ_iff
File: Mathlib/Order/Interval/Set/Disjoint.lean

tactic: simp [not_bddAbove_iff, Set.eq_univ_iff_forall]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
⊢ ⋃ i, Iio (f i) = univ ↔ ¬BddAbove (range f)
state_after: no goals
Theorem: SetTheory.PGame.neg_le_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← neg_neg x, neg_le_neg_iff, neg_neg]
state_before: xl xr : Type u
x y : PGame
⊢ -y ≤ x ↔ -x ≤ y
state_after: no goals
Theorem: TrivSqZeroExt.snd_exp
File: Mathlib/Analysis/NormedSpace/TrivSqZeroExt.lean

tactic: rw [exp_def, snd_add, snd_inl, snd_inr, zero_add]
state_before: 𝕜 : Type u_1
S : Type u_2
R : Type u_3
M : Type u_4
inst✝¹⁷ : Field 𝕜
inst✝¹⁶ : CharZero 𝕜
inst✝¹⁵ : CommRing R
inst✝¹⁴ : AddCommGroup M
inst✝¹³ : Algebra 𝕜 R
inst✝¹² : Module 𝕜 M
inst✝¹¹ : Module R M
inst✝¹⁰ : Module Rᵐᵒᵖ M
inst✝⁹ : IsCentralScalar R M
inst✝⁸ : IsScalarTower 𝕜 R M
inst✝⁷ : TopologicalSpace R
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalRing R
inst✝⁴ : TopologicalAddGroup M
inst✝³ : ContinuousSMul R M
inst✝² : ContinuousSMul Rᵐᵒᵖ M
inst✝¹ : T2Space R
inst✝ : T2Space M
x : tsze R M
⊢ (exp 𝕜 x).snd = exp 𝕜 x.fst • x.snd
state_after: no goals
Theorem: Nat.map_floor
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← map_natCast f, hf.le_iff_le]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁵ : LinearOrderedSemiring α
inst✝⁴ : LinearOrderedSemiring β
inst✝³ : FloorSemiring α
inst✝² : FloorSemiring β
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: le_nhdsAdjoint_iff
File: Mathlib/Topology/Order.lean

tactic: simp only [le_nhdsAdjoint_iff', @isOpen_singleton_iff_nhds_eq_pure α t]
state_before: α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
⊢ t ≤ nhdsAdjoint a f ↔ 𝓝 a ≤ pure a ⊔ f ∧ ∀ (b : α), b ≠ a → IsOpen {b}
state_after: no goals