1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: AddChar.zmodChar_primitive_of_primitive_root
File: Mathlib/NumberTheory/LegendreSymbol/AddCharacter.lean

tactic: apply zmod_char_primitive_of_eq_one_only_at_zero
state_before: R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ζ : C
h : IsPrimitiveRoot ζ n
⊢ (zmodChar n ⋯).IsPrimitive
state_after: case hψ
R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ζ : C
h : IsPrimitiveRoot ζ n
⊢ ∀ (a : ZMod n), (zmodChar n ⋯) a = 1 → a = 0

tactic: intro a ha
state_before: case hψ
R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ζ : C
h : IsPrimitiveRoot ζ n
⊢ ∀ (a : ZMod n), (zmodChar n ⋯) a = 1 → a = 0
state_after: case hψ
R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ζ : C
h : IsPrimitiveRoot ζ n
a : ZMod n
ha : (zmodChar n ⋯) a = 1
⊢ a = 0

tactic: rw [zmodChar_apply, ← pow_zero ζ] at ha
state_before: case hψ
R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ζ : C
h : IsPrimitiveRoot ζ n
a : ZMod n
ha : (zmodChar n ⋯) a = 1
⊢ a = 0
state_after: case hψ
R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ζ : C
h : IsPrimitiveRoot ζ n
a : ZMod n
ha : ζ ^ a.val = ζ ^ 0
⊢ a = 0

tactic: exact (ZMod.val_eq_zero a).mp (IsPrimitiveRoot.pow_inj h (ZMod.val_lt a) (NeZero.pos _) ha)
state_before: case hψ
R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ζ : C
h : IsPrimitiveRoot ζ n
a : ZMod n
ha : ζ ^ a.val = ζ ^ 0
⊢ a = 0
state_after: no goals
Theorem: List.append_sublist_append_right
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: have := h.reverse
state_before: α✝ : Type u_1
l₁ l₂ l : List α✝
h : l₁ ++ l <+ l₂ ++ l
⊢ l₁ <+ l₂
state_after: α✝ : Type u_1
l₁ l₂ l : List α✝
h : l₁ ++ l <+ l₂ ++ l
this : (l₁ ++ l).reverse <+ (l₂ ++ l).reverse
⊢ l₁ <+ l₂

tactic: simp only [reverse_append, append_sublist_append_left, reverse_sublist] at this
state_before: α✝ : Type u_1
l₁ l₂ l : List α✝
h : l₁ ++ l <+ l₂ ++ l
this : (l₁ ++ l).reverse <+ (l₂ ++ l).reverse
⊢ l₁ <+ l₂
state_after: α✝ : Type u_1
l₁ l₂ l : List α✝
h : l₁ ++ l <+ l₂ ++ l
this : l₁ <+ l₂
⊢ l₁ <+ l₂

tactic: exact this
state_before: α✝ : Type u_1
l₁ l₂ l : List α✝
h : l₁ ++ l <+ l₂ ++ l
this : l₁ <+ l₂
⊢ l₁ <+ l₂
state_after: no goals
Theorem: IsWellOrderLimitElement.wellOrderSucc_lt
File: Mathlib/Order/IsWellOrderLimitElement.lean

tactic: obtain ⟨c, hc₁, hc₂⟩ := ha.not_succ b hb
state_before: α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : IsWellOrder α fun x x_1 => x < x_1
a : α
ha : IsWellOrderLimitElement a
b : α
hb : b < a
⊢ wellOrderSucc b < a
state_after: case intro.intro
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : IsWellOrder α fun x x_1 => x < x_1
a : α
ha : IsWellOrderLimitElement a
b : α
hb : b < a
c : α
hc₁ : b < c
hc₂ : c < a
⊢ wellOrderSucc b < a

tactic: exact lt_of_le_of_lt (wellOrderSucc_le hc₁) hc₂
state_before: case intro.intro
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : IsWellOrder α fun x x_1 => x < x_1
a : α
ha : IsWellOrderLimitElement a
b : α
hb : b < a
c : α
hc₁ : b < c
hc₂ : c < a
⊢ wellOrderSucc b < a
state_after: no goals
Theorem: SimplicialObject.Splitting.cofan_inj_πSummand_eq_id
File: Mathlib/AlgebraicTopology/DoldKan/SplitSimplicialObject.lean

tactic: simp [πSummand]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
X : SimplicialObject C
s : Splitting X
inst✝ : HasZeroMorphisms C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ (s.cofan Δ).inj A ≫ s.πSummand A = 𝟙 (summand s.N Δ A)
state_after: no goals
Theorem: Nat.pow_succ_le_ascFactorial
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rw [ascFactorial_zero, Nat.pow_zero]
state_before: n : ℕ
⊢ n ^ 0 ≤ n.ascFactorial 0
state_after: no goals

tactic: rw [Nat.pow_succ, Nat.mul_comm, ascFactorial_succ, ← succ_ascFactorial]
state_before: n k : ℕ
⊢ n ^ (k + 1) ≤ n.ascFactorial (k + 1)
state_after: n k : ℕ
⊢ n * n ^ k ≤ n * n.succ.ascFactorial k

tactic: exact Nat.mul_le_mul (Nat.le_refl n)
  (Nat.le_trans (Nat.pow_le_pow_left (le_succ n) k) (pow_succ_le_ascFactorial n.succ k))
state_before: n k : ℕ
⊢ n * n ^ k ≤ n * n.succ.ascFactorial k
state_after: no goals
Theorem: MeasureTheory.AEEqFun.pair_eq_mk
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: simp only [← pair_mk_mk, mk_coeFn, f.aestronglyMeasurable, g.aestronglyMeasurable]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] β
g : α →ₘ[μ] γ
⊢ f.pair g = mk (fun x => (↑f x, ↑g x)) ⋯
state_after: no goals
Theorem: Filter.map_lift_eq
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [mem_lift_sets hg, mem_lift_sets this, exists_prop, mem_map, Function.comp_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f f₁ f₂ : Filter α
g g₁ g₂ : Set α → Filter β
m : β → γ
hg : Monotone g
this : Monotone (map m ∘ g)
s : Set γ
⊢ s ∈ map m (f.lift g) ↔ s ∈ f.lift (map m ∘ g)
state_after: no goals
Theorem: Seminorm.sSup_apply
File: Mathlib/Analysis/Seminorm.lean

tactic: rw [Seminorm.coe_sSup_eq hp, iSup_apply]
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p q : Seminorm 𝕜 E
x✝ : E
s : Set (Seminorm 𝕜 E)
hp : BddAbove s
x : E
⊢ (sSup s) x = ⨆ p, ↑p x
state_after: no goals
Theorem: Real.Angle.toReal_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← coe_zero, toReal_coe_eq_self_iff]
state_before: ⊢ toReal 0 = 0
state_after: ⊢ -π < 0 ∧ 0 ≤ π

tactic: exact ⟨Left.neg_neg_iff.2 Real.pi_pos, Real.pi_pos.le⟩
state_before: ⊢ -π < 0 ∧ 0 ≤ π
state_after: no goals
Theorem: Ideal.absNorm_mem
File: Mathlib/RingTheory/Ideal/Norm.lean

tactic: rw [absNorm_apply, cardQuot, ← Ideal.Quotient.eq_zero_iff_mem, map_natCast,
  Quotient.index_eq_zero]
state_before: S : Type u_1
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Nontrivial S
inst✝² : IsDedekindDomain S
inst✝¹ : Module.Free ℤ S
inst✝ : Module.Finite ℤ S
I : Ideal S
⊢ ↑(absNorm I) ∈ I
state_after: no goals
Theorem: SimpleGraph.Walk.support_takeUntil_subset
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [← take_spec p h, mem_support_append_iff]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ x✝ y : V
inst✝ : DecidableEq V
u v w : V
p : G.Walk v w
h : u ∈ p.support
x : V
hx : x ∈ (p.takeUntil u h).support
⊢ x ∈ p.support
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ x✝ y : V
inst✝ : DecidableEq V
u v w : V
p : G.Walk v w
h : u ∈ p.support
x : V
hx : x ∈ (p.takeUntil u h).support
⊢ x ∈ (p.takeUntil u h).support ∨ x ∈ (p.dropUntil u h).support

tactic: exact Or.inl hx
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ x✝ y : V
inst✝ : DecidableEq V
u v w : V
p : G.Walk v w
h : u ∈ p.support
x : V
hx : x ∈ (p.takeUntil u h).support
⊢ x ∈ (p.takeUntil u h).support ∨ x ∈ (p.dropUntil u h).support
state_after: no goals
Theorem: Finset.mem_shadow_iff_insert_mem
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

tactic: simp_rw [mem_shadow_iff_exists_sdiff, ← covBy_iff_card_sdiff_eq_one, covBy_iff_exists_insert]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ t ∈ ∂ 𝒜 ↔ ∃ a ∉ t, insert a t ∈ 𝒜
state_after: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ (∃ s ∈ 𝒜, ∃ a ∉ t, insert a t = s) ↔ ∃ a ∉ t, insert a t ∈ 𝒜

tactic: aesop
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ (∃ s ∈ 𝒜, ∃ a ∉ t, insert a t = s) ↔ ∃ a ∉ t, insert a t ∈ 𝒜
state_after: no goals
Theorem: EqualCharZero.PNat.isUnit_natCast
File: Mathlib/Algebra/CharP/MixedCharZero.lean

tactic: rw [← Ideal.span_singleton_eq_top]
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
⊢ IsUnit ↑↑n
state_after: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
⊢ Ideal.span {↑↑n} = ⊤

tactic: apply not_imp_comm.mp (h.elim (Ideal.span {↑n}))
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
⊢ Ideal.span {↑↑n} = ⊤
state_after: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
⊢ ¬CharZero (R ⧸ Ideal.span {↑↑n})

tactic: intro h_char_zero
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
⊢ ¬CharZero (R ⧸ Ideal.span {↑↑n})
state_after: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
h_char_zero : CharZero (R ⧸ Ideal.span {↑↑n})
⊢ False

tactic: apply h_char_zero.cast_injective.ne n.ne_zero
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
h_char_zero : CharZero (R ⧸ Ideal.span {↑↑n})
⊢ False
state_after: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
h_char_zero : CharZero (R ⧸ Ideal.span {↑↑n})
⊢ ↑↑n = ↑0

tactic: rw [← map_natCast (Ideal.Quotient.mk _), Nat.cast_zero, Ideal.Quotient.eq_zero_iff_mem]
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
h_char_zero : CharZero (R ⧸ Ideal.span {↑↑n})
⊢ ↑↑n = ↑0
state_after: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
h_char_zero : CharZero (R ⧸ Ideal.span {↑↑n})
⊢ ↑↑n ∈ Ideal.span {↑↑n}

tactic: exact Ideal.subset_span (Set.mem_singleton _)
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
h_char_zero : CharZero (R ⧸ Ideal.span {↑↑n})
⊢ ↑↑n ∈ Ideal.span {↑↑n}
state_after: no goals
Theorem: QPF.Fix.dest_mk
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: unfold Fix.dest
state_before: F : Type u → Type u
q : QPF F
x : F (Fix F)
⊢ (mk x).dest = x
state_after: F : Type u → Type u
q : QPF F
x : F (Fix F)
⊢ rec (Functor.map mk) (mk x) = x

tactic: rw [Fix.rec_eq, ← Fix.dest, ← comp_map]
state_before: F : Type u → Type u
q : QPF F
x : F (Fix F)
⊢ rec (Functor.map mk) (mk x) = x
state_after: F : Type u → Type u
q : QPF F
x : F (Fix F)
⊢ (mk ∘ dest) <$> x = x

tactic: conv =>
  rhs
  rw [← id_map x]
state_before: F : Type u → Type u
q : QPF F
x : F (Fix F)
⊢ (mk ∘ dest) <$> x = x
state_after: F : Type u → Type u
q : QPF F
x : F (Fix F)
⊢ (mk ∘ dest) <$> x = id <$> x

tactic: congr with x
state_before: F : Type u → Type u
q : QPF F
x : F (Fix F)
⊢ (mk ∘ dest) <$> x = id <$> x
state_after: case e_a.h
F : Type u → Type u
q : QPF F
x✝ : F (Fix F)
x : Fix F
⊢ (mk ∘ dest) x = id x

tactic: apply Fix.mk_dest
state_before: case e_a.h
F : Type u → Type u
q : QPF F
x✝ : F (Fix F)
x : Fix F
⊢ (mk ∘ dest) x = id x
state_after: no goals
Theorem: CliffordAlgebra.changeForm_one
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

tactic: simpa using changeForm_algebraMap h (1 : R)
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q Q' Q'' : QuadraticForm R M
B B' : BilinForm R M
h : B.toQuadraticForm = Q' - Q
h' : B'.toQuadraticForm = Q'' - Q'
⊢ (changeForm h) 1 = 1
state_after: no goals
Theorem: EMetric.tendstoUniformlyOn_iff
File: Mathlib/Topology/EMetricSpace/Basic.lean

tactic: refine ⟨fun H ε hε => H _ (edist_mem_uniformity hε), fun H u hu => ?_⟩
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
ι : Type u_2
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
⊢ TendstoUniformlyOn F f p s ↔ ∀ ε > 0, ∀ᶠ (n : ι) in p, ∀ x ∈ s, edist (f x) (F n x) < ε
state_after: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
ι : Type u_2
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
H : ∀ ε > 0, ∀ᶠ (n : ι) in p, ∀ x ∈ s, edist (f x) (F n x) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
⊢ ∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ u

tactic: rcases mem_uniformity_edist.1 hu with ⟨ε, εpos, hε⟩
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
ι : Type u_2
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
H : ∀ ε > 0, ∀ᶠ (n : ι) in p, ∀ x ∈ s, edist (f x) (F n x) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
⊢ ∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ u
state_after: case intro.intro
α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
ι : Type u_2
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
H : ∀ ε > 0, ∀ᶠ (n : ι) in p, ∀ x ∈ s, edist (f x) (F n x) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
ε : ℝ≥0∞
εpos : ε > 0
hε : ∀ {a b : α}, edist a b < ε → (a, b) ∈ u
⊢ ∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ u

tactic: exact (H ε εpos).mono fun n hs x hx => hε (hs x hx)
state_before: case intro.intro
α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
ι : Type u_2
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
H : ∀ ε > 0, ∀ᶠ (n : ι) in p, ∀ x ∈ s, edist (f x) (F n x) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
ε : ℝ≥0∞
εpos : ε > 0
hε : ∀ {a b : α}, edist a b < ε → (a, b) ∈ u
⊢ ∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ u
state_after: no goals
Theorem: Primrec.vector_ofFn
File: Mathlib/Computability/Primrec.lean

tactic: simp [list_ofFn hf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : Fin n → α → σ
hf : ∀ (i : Fin n), Primrec (f i)
⊢ Primrec fun a => (Vector.ofFn fun i => f i a).toList
state_after: no goals
Theorem: Nat.primesBelow_succ
File: Mathlib/NumberTheory/SmoothNumbers.lean

tactic: rw [primesBelow, primesBelow, Finset.range_succ, Finset.filter_insert]
state_before: n : ℕ
⊢ n.succ.primesBelow = if Prime n then insert n n.primesBelow else n.primesBelow
state_after: no goals
Theorem: Fin.snoc_comp_cast_add
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: unfold comp
state_before: m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ (last n✝)
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ i.castSucc
i : Fin n✝
y : α✝ i.castSucc
z : α✝ (last n✝)
n m : ℕ
α : Type u_1
f : Fin (n + m) → α
a : α
⊢ ∀ (x : Fin n), (snoc f a ∘ castAdd (m + 1)) x = (f ∘ castAdd m) x
state_after: m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ (last n✝)
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ i.castSucc
i : Fin n✝
y : α✝ i.castSucc
z : α✝ (last n✝)
n m : ℕ
α : Type u_1
f : Fin (n + m) → α
a : α
⊢ ∀ (x : Fin n), snoc f a (castAdd (m + 1) x) = f (castAdd m x)

tactic: exact snoc_cast_add _ _
state_before: m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ (last n✝)
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ i.castSucc
i : Fin n✝
y : α✝ i.castSucc
z : α✝ (last n✝)
n m : ℕ
α : Type u_1
f : Fin (n + m) → α
a : α
⊢ ∀ (x : Fin n), snoc f a (castAdd (m + 1) x) = f (castAdd m x)
state_after: no goals
Theorem: Module.AEval.C_smul
File: Mathlib/Algebra/Polynomial/Module/AEval.lean

tactic: simp
state_before: R : Type u_1
A : Type u_3
M : Type u_2
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
a : A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module A M
inst✝¹ : Module R M
inst✝ : IsScalarTower R A M
t : R
m : AEval R M a
⊢ (of R M a).symm (C t • m) = (of R M a).symm (t • m)
state_after: no goals
Theorem: Nat.lt_factorial_self
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: have : 0 < n := by omega
state_before: m n✝ n : ℕ
hi : 3 ≤ n
⊢ n < n !
state_after: m n✝ n : ℕ
hi : 3 ≤ n
this : 0 < n
⊢ n < n !

tactic: have hn : 1 < pred n := le_pred_of_lt (succ_le_iff.mp hi)
state_before: m n✝ n : ℕ
hi : 3 ≤ n
this : 0 < n
⊢ n < n !
state_after: m n✝ n : ℕ
hi : 3 ≤ n
this : 0 < n
hn : 1 < n.pred
⊢ n < n !

tactic: rw [← succ_pred_eq_of_pos ‹0 < n›, factorial_succ]
state_before: m n✝ n : ℕ
hi : 3 ≤ n
this : 0 < n
hn : 1 < n.pred
⊢ n < n !
state_after: m n✝ n : ℕ
hi : 3 ≤ n
this : 0 < n
hn : 1 < n.pred
⊢ n.pred.succ < (n.pred + 1) * n.pred !

tactic: exact (Nat.lt_mul_iff_one_lt_right (pred n).succ_pos).2
  ((Nat.lt_of_lt_of_le hn (self_le_factorial _)))
state_before: m n✝ n : ℕ
hi : 3 ≤ n
this : 0 < n
hn : 1 < n.pred
⊢ n.pred.succ < (n.pred + 1) * n.pred !
state_after: no goals

tactic: omega
state_before: m n✝ n : ℕ
hi : 3 ≤ n
⊢ 0 < n
state_after: no goals
Theorem: Cardinal.lift_le_ofENat
File: Mathlib/SetTheory/Cardinal/ENat.lean

tactic: rw [← lift_ofENat.{u, v}, lift_le]
state_before: x : Cardinal.{v}
m : ℕ∞
⊢ lift.{u, v} x ≤ ↑m ↔ x ≤ ↑m
state_after: no goals
Theorem: MeasureTheory.null_iff_of_isMulLeftInvariant
File: Mathlib/MeasureTheory/Group/Measure.lean

tactic: rcases eq_zero_or_neZero μ with rfl|hμ
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H
inst✝⁵ : TopologicalSpace G
inst✝⁴ : BorelSpace G
μ : Measure G
inst✝³ : Group G
inst✝² : TopologicalGroup G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : μ.Regular
s : Set G
hs : IsOpen s
⊢ μ s = 0 ↔ s = ∅ ∨ μ = 0
state_after: case inl
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H
inst✝⁵ : TopologicalSpace G
inst✝⁴ : BorelSpace G
inst✝³ : Group G
inst✝² : TopologicalGroup G
s : Set G
hs : IsOpen s
inst✝¹ : IsMulLeftInvariant 0
inst✝ : Regular 0
⊢ 0 s = 0 ↔ s = ∅ ∨ 0 = 0

case inr
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H
inst✝⁵ : TopologicalSpace G
inst✝⁴ : BorelSpace G
μ : Measure G
inst✝³ : Group G
inst✝² : TopologicalGroup G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : μ.Regular
s : Set G
hs : IsOpen s
hμ : NeZero μ
⊢ μ s = 0 ↔ s = ∅ ∨ μ = 0

tactic: simp
state_before: case inl
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H
inst✝⁵ : TopologicalSpace G
inst✝⁴ : BorelSpace G
inst✝³ : Group G
inst✝² : TopologicalGroup G
s : Set G
hs : IsOpen s
inst✝¹ : IsMulLeftInvariant 0
inst✝ : Regular 0
⊢ 0 s = 0 ↔ s = ∅ ∨ 0 = 0
state_after: no goals

tactic: simp only [or_false_iff, hs.measure_eq_zero_iff μ, NeZero.ne μ]
state_before: case inr
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H
inst✝⁵ : TopologicalSpace G
inst✝⁴ : BorelSpace G
μ : Measure G
inst✝³ : Group G
inst✝² : TopologicalGroup G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : μ.Regular
s : Set G
hs : IsOpen s
hμ : NeZero μ
⊢ μ s = 0 ↔ s = ∅ ∨ μ = 0
state_after: no goals
Theorem: Real.tendsto_sin_neg_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: convert continuous_sin.continuousWithinAt.tendsto using 2
state_before: ⊢ Tendsto sin (𝓝[>] (-(π / 2))) (𝓝 (-1))
state_after: case h.e'_5.h.e'_3

⊢ -1 = sin (-(π / 2))

tactic: simp
state_before: case h.e'_5.h.e'_3

⊢ -1 = sin (-(π / 2))
state_after: no goals
Theorem: Submodule.iSup_induction
File: Mathlib/LinearAlgebra/Span.lean

tactic: rw [← mem_toAddSubmonoid, iSup_toAddSubmonoid] at hx
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x✝ : M
p✝ p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
ι : Sort u_9
p : ι → Submodule R M
C : M → Prop
x : M
hx : x ∈ ⨆ i, p i
hp : ∀ (i : ι), ∀ x ∈ p i, C x
h0 : C 0
hadd : ∀ (x y : M), C x → C y → C (x + y)
⊢ C x
state_after: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x✝ : M
p✝ p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
ι : Sort u_9
p : ι → Submodule R M
C : M → Prop
x : M
hx : x ∈ ⨆ i, (p i).toAddSubmonoid
hp : ∀ (i : ι), ∀ x ∈ p i, C x
h0 : C 0
hadd : ∀ (x y : M), C x → C y → C (x + y)
⊢ C x

tactic: exact AddSubmonoid.iSup_induction (x := x) _ hx hp h0 hadd
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x✝ : M
p✝ p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
ι : Sort u_9
p : ι → Submodule R M
C : M → Prop
x : M
hx : x ∈ ⨆ i, (p i).toAddSubmonoid
hp : ∀ (i : ι), ∀ x ∈ p i, C x
h0 : C 0
hadd : ∀ (x y : M), C x → C y → C (x + y)
⊢ C x
state_after: no goals
Theorem: Polynomial.taylor_X
File: Mathlib/Algebra/Polynomial/Taylor.lean

tactic: simp only [taylor_apply, X_comp]
state_before: R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
⊢ (taylor r) X = X + C r
state_after: no goals
Theorem: List.takeWhile_eq_nil_iff
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with x xs IH
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
⊢ takeWhile p l = [] ↔ ∀ (hl : 0 < l.length), ¬p (l.nthLe 0 hl) = true
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
⊢ takeWhile p [] = [] ↔ ∀ (hl : 0 < [].length), ¬p ([].nthLe 0 hl) = true

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
x : α
xs : List α
IH : takeWhile p xs = [] ↔ ∀ (hl : 0 < xs.length), ¬p (xs.nthLe 0 hl) = true
⊢ takeWhile p (x :: xs) = [] ↔ ∀ (hl : 0 < (x :: xs).length), ¬p ((x :: xs).nthLe 0 hl) = true

tactic: simp only [takeWhile_nil, Bool.not_eq_true, true_iff]
state_before: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
⊢ takeWhile p [] = [] ↔ ∀ (hl : 0 < [].length), ¬p ([].nthLe 0 hl) = true
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
⊢ ∀ (hl : 0 < [].length), p ([].nthLe 0 hl) = false

tactic: intro h
state_before: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
⊢ ∀ (hl : 0 < [].length), p ([].nthLe 0 hl) = false
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
h : 0 < [].length
⊢ p ([].nthLe 0 h) = false

tactic: simp at h
state_before: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
h : 0 < [].length
⊢ p ([].nthLe 0 h) = false
state_after: no goals

tactic: by_cases hp : p x <;> simp [hp, takeWhile_cons, IH, nthLe_cons]
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
x : α
xs : List α
IH : takeWhile p xs = [] ↔ ∀ (hl : 0 < xs.length), ¬p (xs.nthLe 0 hl) = true
⊢ takeWhile p (x :: xs) = [] ↔ ∀ (hl : 0 < (x :: xs).length), ¬p ((x :: xs).nthLe 0 hl) = true
state_after: no goals
Theorem: MeasureTheory.Measure.integral_comp_inv_mul_left
File: Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean

tactic: simp_rw [← smul_eq_mul, Measure.integral_comp_inv_smul, FiniteDimensional.finrank_self, pow_one]
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : MeasurableSpace E
inst✝⁴ : BorelSpace E
inst✝³ : FiniteDimensional ℝ E
μ : Measure E
inst✝² : μ.IsAddHaarMeasure
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
s : Set E
g : ℝ → F
a : ℝ
⊢ ∫ (x : ℝ), g (a⁻¹ * x) = |a| • ∫ (y : ℝ), g y
state_after: no goals