1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Real.ciInf_const_zero
File: Mathlib/Data/Real/Archimedean.lean

tactic: cases isEmpty_or_nonempty α
state_before: α : Sort u_1
⊢ ⨅ x, 0 = 0
state_after: case inl
α : Sort u_1
h✝ : IsEmpty α
⊢ ⨅ x, 0 = 0

case inr
α : Sort u_1
h✝ : Nonempty α
⊢ ⨅ x, 0 = 0

tactic: exact Real.iInf_of_isEmpty _
state_before: case inl
α : Sort u_1
h✝ : IsEmpty α
⊢ ⨅ x, 0 = 0
state_after: no goals

tactic: exact ciInf_const
state_before: case inr
α : Sort u_1
h✝ : Nonempty α
⊢ ⨅ x, 0 = 0
state_after: no goals
Theorem: Finset.inv_zero
File: Mathlib/Data/Finset/Pointwise.lean

tactic: ext
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s t : Finset β
a : α
b : β
inst✝ : DecidableEq α
⊢ 0⁻¹ = 0
state_after: case a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s t : Finset β
a : α
b : β
inst✝ : DecidableEq α
a✝ : α
⊢ a✝ ∈ 0⁻¹ ↔ a✝ ∈ 0

tactic: simp
state_before: case a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s t : Finset β
a : α
b : β
inst✝ : DecidableEq α
a✝ : α
⊢ a✝ ∈ 0⁻¹ ↔ a✝ ∈ 0
state_after: no goals
Theorem: IsPiSystem.pi
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: rintro _ ⟨s₁, hs₁, rfl⟩ _ ⟨s₂, hs₂, rfl⟩ hst
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
⊢ IsPiSystem (univ.pi '' univ.pi C)
state_after: case intro.intro.intro.intro
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
s₁ : (i : ι) → Set (α i)
hs₁ : s₁ ∈ univ.pi C
s₂ : (i : ι) → Set (α i)
hs₂ : s₂ ∈ univ.pi C
hst : (univ.pi s₁ ∩ univ.pi s₂).Nonempty
⊢ univ.pi s₁ ∩ univ.pi s₂ ∈ univ.pi '' univ.pi C

tactic: rw [← pi_inter_distrib] at hst ⊢
state_before: case intro.intro.intro.intro
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
s₁ : (i : ι) → Set (α i)
hs₁ : s₁ ∈ univ.pi C
s₂ : (i : ι) → Set (α i)
hs₂ : s₂ ∈ univ.pi C
hst : (univ.pi s₁ ∩ univ.pi s₂).Nonempty
⊢ univ.pi s₁ ∩ univ.pi s₂ ∈ univ.pi '' univ.pi C
state_after: case intro.intro.intro.intro
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
s₁ : (i : ι) → Set (α i)
hs₁ : s₁ ∈ univ.pi C
s₂ : (i : ι) → Set (α i)
hs₂ : s₂ ∈ univ.pi C
hst : (univ.pi fun i => s₁ i ∩ s₂ i).Nonempty
⊢ (univ.pi fun i => s₁ i ∩ s₂ i) ∈ univ.pi '' univ.pi C

tactic: rw [univ_pi_nonempty_iff] at hst
state_before: case intro.intro.intro.intro
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
s₁ : (i : ι) → Set (α i)
hs₁ : s₁ ∈ univ.pi C
s₂ : (i : ι) → Set (α i)
hs₂ : s₂ ∈ univ.pi C
hst : (univ.pi fun i => s₁ i ∩ s₂ i).Nonempty
⊢ (univ.pi fun i => s₁ i ∩ s₂ i) ∈ univ.pi '' univ.pi C
state_after: case intro.intro.intro.intro
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
s₁ : (i : ι) → Set (α i)
hs₁ : s₁ ∈ univ.pi C
s₂ : (i : ι) → Set (α i)
hs₂ : s₂ ∈ univ.pi C
hst : ∀ (i : ι), (s₁ i ∩ s₂ i).Nonempty
⊢ (univ.pi fun i => s₁ i ∩ s₂ i) ∈ univ.pi '' univ.pi C

tactic: exact mem_image_of_mem _ fun i _ => hC i _ (hs₁ i (mem_univ i)) _ (hs₂ i (mem_univ i)) (hst i)
state_before: case intro.intro.intro.intro
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
s₁ : (i : ι) → Set (α i)
hs₁ : s₁ ∈ univ.pi C
s₂ : (i : ι) → Set (α i)
hs₂ : s₂ ∈ univ.pi C
hst : ∀ (i : ι), (s₁ i ∩ s₂ i).Nonempty
⊢ (univ.pi fun i => s₁ i ∩ s₂ i) ∈ univ.pi '' univ.pi C
state_after: no goals
Theorem: Mathlib.Meta.NormNum.IsNat.to_isRat
File: Mathlib/Tactic/NormNum/Result.lean

tactic: simp
state_before: α : Type u_1
inst✝ : Ring α
n✝ : ℕ
⊢ 1 * ↑1 = 1
state_after: no goals

tactic: simp
state_before: α : Type u_1
inst✝ : Ring α
n✝ : ℕ
⊢ ↑1 * 1 = 1
state_after: no goals

tactic: simp
state_before: α : Type u_1
inst✝ : Ring α
n✝ : ℕ
⊢ ↑n✝ = ↑(Int.ofNat n✝) * ⅟↑1
state_after: no goals
Theorem: MeasureTheory.ContinuousOn.hasBoxIntegral
File: Mathlib/Analysis/BoxIntegral/Integrability.lean

tactic: obtain ⟨y, hy⟩ := BoxIntegral.integrable_of_continuousOn l hc μ
state_before: ι : Type u
E : Type v
inst✝⁴ : Fintype ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f : (ι → ℝ) → E
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
I : Box ι
hc : ContinuousOn f (Box.Icc I)
l : IntegrationParams
⊢ HasIntegral I l f μ.toBoxAdditive.toSMul (∫ (x : ι → ℝ) in ↑I, f x ∂μ)
state_after: case intro
ι : Type u
E : Type v
inst✝⁴ : Fintype ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f : (ι → ℝ) → E
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
I : Box ι
hc : ContinuousOn f (Box.Icc I)
l : IntegrationParams
y : E
hy : HasIntegral I l f μ.toBoxAdditive.toSMul y
⊢ HasIntegral I l f μ.toBoxAdditive.toSMul (∫ (x : ι → ℝ) in ↑I, f x ∂μ)

tactic: convert hy
state_before: case intro
ι : Type u
E : Type v
inst✝⁴ : Fintype ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f : (ι → ℝ) → E
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
I : Box ι
hc : ContinuousOn f (Box.Icc I)
l : IntegrationParams
y : E
hy : HasIntegral I l f μ.toBoxAdditive.toSMul y
⊢ HasIntegral I l f μ.toBoxAdditive.toSMul (∫ (x : ι → ℝ) in ↑I, f x ∂μ)
state_after: case h.e'_13
ι : Type u
E : Type v
inst✝⁴ : Fintype ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f : (ι → ℝ) → E
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
I : Box ι
hc : ContinuousOn f (Box.Icc I)
l : IntegrationParams
y : E
hy : HasIntegral I l f μ.toBoxAdditive.toSMul y
⊢ ∫ (x : ι → ℝ) in ↑I, f x ∂μ = y

tactic: have : IntegrableOn f I μ :=
  IntegrableOn.mono_set (hc.integrableOn_compact I.isCompact_Icc) Box.coe_subset_Icc
state_before: case h.e'_13
ι : Type u
E : Type v
inst✝⁴ : Fintype ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f : (ι → ℝ) → E
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
I : Box ι
hc : ContinuousOn f (Box.Icc I)
l : IntegrationParams
y : E
hy : HasIntegral I l f μ.toBoxAdditive.toSMul y
⊢ ∫ (x : ι → ℝ) in ↑I, f x ∂μ = y
state_after: case h.e'_13
ι : Type u
E : Type v
inst✝⁴ : Fintype ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f : (ι → ℝ) → E
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
I : Box ι
hc : ContinuousOn f (Box.Icc I)
l : IntegrationParams
y : E
hy : HasIntegral I l f μ.toBoxAdditive.toSMul y
this : IntegrableOn f (↑I) μ
⊢ ∫ (x : ι → ℝ) in ↑I, f x ∂μ = y

tactic: exact HasIntegral.unique (IntegrableOn.hasBoxIntegral this ⊥ rfl) (HasIntegral.mono hy bot_le)
state_before: case h.e'_13
ι : Type u
E : Type v
inst✝⁴ : Fintype ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f : (ι → ℝ) → E
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
I : Box ι
hc : ContinuousOn f (Box.Icc I)
l : IntegrationParams
y : E
hy : HasIntegral I l f μ.toBoxAdditive.toSMul y
this : IntegrableOn f (↑I) μ
⊢ ∫ (x : ι → ℝ) in ↑I, f x ∂μ = y
state_after: no goals
Theorem: List.get?_enum
File: Mathlib/Data/List/Enum.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
l : List α
n : ℕ
⊢ l.enum.get? n = Option.map (fun a => (n, a)) (l.get? n)
state_after: no goals
Theorem: continuous_if'
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [continuous_iff_continuousOn_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
p : α → Prop
f g : α → β
inst✝ : (a : α) → Decidable (p a)
hpf : ∀ a ∈ frontier {x | p x}, Tendsto f (𝓝[{x | p x}] a) (𝓝 (if p a then f a else g a))
hpg : ∀ a ∈ frontier {x | p x}, Tendsto g (𝓝[{x | ¬p x}] a) (𝓝 (if p a then f a else g a))
hf : ContinuousOn f {x | p x}
hg : ContinuousOn g {x | ¬p x}
⊢ Continuous fun a => if p a then f a else g a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
p : α → Prop
f g : α → β
inst✝ : (a : α) → Decidable (p a)
hpf : ∀ a ∈ frontier {x | p x}, Tendsto f (𝓝[{x | p x}] a) (𝓝 (if p a then f a else g a))
hpg : ∀ a ∈ frontier {x | p x}, Tendsto g (𝓝[{x | ¬p x}] a) (𝓝 (if p a then f a else g a))
hf : ContinuousOn f {x | p x}
hg : ContinuousOn g {x | ¬p x}
⊢ ContinuousOn (fun a => if p a then f a else g a) univ

tactic: apply ContinuousOn.if' <;> simp [*] <;> assumption
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
p : α → Prop
f g : α → β
inst✝ : (a : α) → Decidable (p a)
hpf : ∀ a ∈ frontier {x | p x}, Tendsto f (𝓝[{x | p x}] a) (𝓝 (if p a then f a else g a))
hpg : ∀ a ∈ frontier {x | p x}, Tendsto g (𝓝[{x | ¬p x}] a) (𝓝 (if p a then f a else g a))
hf : ContinuousOn f {x | p x}
hg : ContinuousOn g {x | ¬p x}
⊢ ContinuousOn (fun a => if p a then f a else g a) univ
state_after: no goals
Theorem: Finset.prod_Icc_succ_top
File: Mathlib/Algebra/BigOperators/Intervals.lean

tactic: rw [← Nat.Ico_succ_right, prod_Ico_succ_top hab, Nat.Ico_succ_right]
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a✝ : α
g f✝ : α → M
a b : ℕ
hab : a ≤ b + 1
f : ℕ → M
⊢ ∏ k ∈ Icc a (b + 1), f k = (∏ k ∈ Icc a b, f k) * f (b + 1)
state_after: no goals
Theorem: Ordinal.deriv_add_eq_mul_omega_add
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: revert b
state_before: a b : Ordinal.{u}
⊢ deriv (fun x => a + x) b = a * ω + b
state_after: a : Ordinal.{u}
⊢ ∀ (b : Ordinal.{u}), deriv (fun x => a + x) b = a * ω + b

tactic: rw [← funext_iff, IsNormal.eq_iff_zero_and_succ (deriv_isNormal _) (add_isNormal _)]
state_before: a : Ordinal.{u}
⊢ ∀ (b : Ordinal.{u}), deriv (fun x => a + x) b = a * ω + b
state_after: a : Ordinal.{u}
⊢ deriv (fun x => a + x) 0 = a * ω + 0 ∧
    ∀ (a_1 : Ordinal.{u}),
      deriv (fun x => a + x) a_1 = a * ω + a_1 → deriv (fun x => a + x) (succ a_1) = a * ω + succ a_1

tactic: refine ⟨?_, fun a h => ?_⟩
state_before: a : Ordinal.{u}
⊢ deriv (fun x => a + x) 0 = a * ω + 0 ∧
    ∀ (a_1 : Ordinal.{u}),
      deriv (fun x => a + x) a_1 = a * ω + a_1 → deriv (fun x => a + x) (succ a_1) = a * ω + succ a_1
state_after: case refine_1
a : Ordinal.{u}
⊢ deriv (fun x => a + x) 0 = a * ω + 0

case refine_2
a✝ a : Ordinal.{u}
h : deriv (fun x => a✝ + x) a = a✝ * ω + a
⊢ deriv (fun x => a✝ + x) (succ a) = a✝ * ω + succ a

tactic: rw [deriv_zero, add_zero]
state_before: case refine_1
a : Ordinal.{u}
⊢ deriv (fun x => a + x) 0 = a * ω + 0
state_after: case refine_1
a : Ordinal.{u}
⊢ nfp (fun x => a + x) 0 = a * ω

tactic: exact nfp_add_zero a
state_before: case refine_1
a : Ordinal.{u}
⊢ nfp (fun x => a + x) 0 = a * ω
state_after: no goals

tactic: rw [deriv_succ, h, add_succ]
state_before: case refine_2
a✝ a : Ordinal.{u}
h : deriv (fun x => a✝ + x) a = a✝ * ω + a
⊢ deriv (fun x => a✝ + x) (succ a) = a✝ * ω + succ a
state_after: case refine_2
a✝ a : Ordinal.{u}
h : deriv (fun x => a✝ + x) a = a✝ * ω + a
⊢ nfp (fun x => a✝ + x) (succ (a✝ * ω + a)) = succ (a✝ * ω + a)

tactic: exact nfp_eq_self (add_eq_right_iff_mul_omega_le.2 ((le_add_right _ _).trans (le_succ _)))
state_before: case refine_2
a✝ a : Ordinal.{u}
h : deriv (fun x => a✝ + x) a = a✝ * ω + a
⊢ nfp (fun x => a✝ + x) (succ (a✝ * ω + a)) = succ (a✝ * ω + a)
state_after: no goals
Theorem: CategoryTheory.SimplicialCategory.sHomWhiskerRight_id
File: Mathlib/AlgebraicTopology/SimplicialCategory/Basic.lean

tactic: simp [sHomWhiskerRight, homEquiv_id]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : SimplicialCategory C
K L : C
⊢ sHomWhiskerRight (𝟙 K) L = 𝟙 (sHom K L)
state_after: no goals
Theorem: nhds_le_of_le
File: Mathlib/Topology/Basic.lean

tactic: rw [nhds_def]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
f : Filter X
h : x ∈ s
o : IsOpen s
sf : 𝓟 s ≤ f
⊢ 𝓝 x ≤ f
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
f : Filter X
h : x ∈ s
o : IsOpen s
sf : 𝓟 s ≤ f
⊢ ⨅ s ∈ {s | x ∈ s ∧ IsOpen s}, 𝓟 s ≤ f

tactic: exact iInf₂_le_of_le s ⟨h, o⟩ sf
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
f : Filter X
h : x ∈ s
o : IsOpen s
sf : 𝓟 s ≤ f
⊢ ⨅ s ∈ {s | x ∈ s ∧ IsOpen s}, 𝓟 s ≤ f
state_after: no goals
Theorem: DihedralGroup.reciprocalFactors_even
File: Mathlib/GroupTheory/CommutingProbability.lean

tactic: have h1 : n ≠ 1 := by
  rintro rfl
  norm_num at h2
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
n : ℕ
h0 : n ≠ 0
h2 : Even n
⊢ reciprocalFactors n = 3 :: reciprocalFactors (n / 2)
state_after: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
n : ℕ
h0 : n ≠ 0
h2 : Even n
h1 : n ≠ 1
⊢ reciprocalFactors n = 3 :: reciprocalFactors (n / 2)

tactic: rw [reciprocalFactors, dif_neg h0, dif_neg h1, if_pos h2]
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
n : ℕ
h0 : n ≠ 0
h2 : Even n
h1 : n ≠ 1
⊢ reciprocalFactors n = 3 :: reciprocalFactors (n / 2)
state_after: no goals

tactic: rintro rfl
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
n : ℕ
h0 : n ≠ 0
h2 : Even n
⊢ n ≠ 1
state_after: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
h0 : 1 ≠ 0
h2 : Even 1
⊢ False

tactic: norm_num at h2
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
h0 : 1 ≠ 0
h2 : Even 1
⊢ False
state_after: no goals
Theorem: CoxeterSystem.length_simple
File: Mathlib/GroupTheory/Coxeter/Length.lean

tactic: apply Nat.le_antisymm
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
⊢ cs.length (cs.simple i) = 1
state_after: case h₁
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
⊢ cs.length (cs.simple i) ≤ 1

case h₂
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
⊢ 1 ≤ cs.length (cs.simple i)

tactic: simpa using cs.length_wordProd_le [i]
state_before: case h₁
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
⊢ cs.length (cs.simple i) ≤ 1
state_after: no goals

tactic: by_contra! length_lt_one
state_before: case h₂
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
⊢ 1 ≤ cs.length (cs.simple i)
state_after: case h₂
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
length_lt_one : cs.length (cs.simple i) < 1
⊢ False

tactic: have : cs.lengthParity (s i) = Multiplicative.ofAdd 0 := by
  rw [lengthParity_eq_ofAdd_length, Nat.lt_one_iff.mp length_lt_one, Nat.cast_zero]
state_before: case h₂
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
length_lt_one : cs.length (cs.simple i) < 1
⊢ False
state_after: case h₂
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
length_lt_one : cs.length (cs.simple i) < 1
this : cs.lengthParity (cs.simple i) = Multiplicative.ofAdd 0
⊢ False

tactic: have : Multiplicative.ofAdd (0 : ZMod 2) = Multiplicative.ofAdd 1 :=
  this.symm.trans (cs.lengthParity_simple i)
state_before: case h₂
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
length_lt_one : cs.length (cs.simple i) < 1
this : cs.lengthParity (cs.simple i) = Multiplicative.ofAdd 0
⊢ False
state_after: case h₂
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
length_lt_one : cs.length (cs.simple i) < 1
this✝ : cs.lengthParity (cs.simple i) = Multiplicative.ofAdd 0
this : Multiplicative.ofAdd 0 = Multiplicative.ofAdd 1
⊢ False

tactic: contradiction
state_before: case h₂
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
length_lt_one : cs.length (cs.simple i) < 1
this✝ : cs.lengthParity (cs.simple i) = Multiplicative.ofAdd 0
this : Multiplicative.ofAdd 0 = Multiplicative.ofAdd 1
⊢ False
state_after: no goals

tactic: rw [lengthParity_eq_ofAdd_length, Nat.lt_one_iff.mp length_lt_one, Nat.cast_zero]
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
length_lt_one : cs.length (cs.simple i) < 1
⊢ cs.lengthParity (cs.simple i) = Multiplicative.ofAdd 0
state_after: no goals
Theorem: LinearMap.ker_restrict
File: Mathlib/Algebra/Module/Submodule/Ker.lean

tactic: rw [restrict_eq_codRestrict_domRestrict, ker_codRestrict]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
K : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₃ : Type u_9
V : Type u_10
V₂ : Type u_11
inst✝¹⁴ : Semiring R
inst✝¹³ : Semiring R₂
inst✝¹² : Semiring R₃
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁸ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁷ : Module R M
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝⁴ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_12
inst✝³ : FunLike F M M₂
inst✝² : SemilinearMapClass F τ₁₂ M M₂
inst✝¹ : AddCommMonoid M₁
inst✝ : Module R M₁
p : Submodule R M
q : Submodule R M₁
f : M →ₗ[R] M₁
hf : ∀ x ∈ p, f x ∈ q
⊢ ker (f.restrict hf) = ker (f.domRestrict p)
state_after: no goals
Theorem: LowerSet.compl_sInf
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp only [coe_compl, coe_sInf, compl_iInter₂, UpperSet.coe_iInf₂]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
s t : LowerSet α
a : α
S : Set (LowerSet α)
⊢ ↑(sInf S).compl = ↑(⨅ s ∈ S, s.compl)
state_after: no goals
Theorem: Nat.cast_one
File: Mathlib/Data/Nat/Cast/Defs.lean

tactic: rw [cast_succ, Nat.cast_zero, zero_add]
state_before: R : Type u_1
inst✝ : AddMonoidWithOne R
⊢ ↑1 = 1
state_after: no goals
Theorem: selfAdjointPart_comp_subtype_skewAdjoint
File: Mathlib/Algebra/Star/Module.lean

tactic: simp [hx]
state_before: R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
x✝ : ↥(skewAdjoint.submodule R A)
x : A
hx : star x = -x
⊢ ↑((selfAdjointPart R ∘ₗ (skewAdjoint.submodule R A).subtype) ⟨x, hx⟩) = ↑(0 ⟨x, hx⟩)
state_after: no goals
Theorem: ZetaAsymptotics.term_sum_one
File: Mathlib/NumberTheory/Harmonic/ZetaAsymp.lean

tactic: induction' N with N hN
state_before: N : ℕ
⊢ term_sum 1 N = log (↑N + 1) - ↑(harmonic (N + 1)) + 1
state_after: case zero

⊢ term_sum 1 0 = log (↑0 + 1) - ↑(harmonic (0 + 1)) + 1

case succ
N : ℕ
hN : term_sum 1 N = log (↑N + 1) - ↑(harmonic (N + 1)) + 1
⊢ term_sum 1 (N + 1) = log (↑(N + 1) + 1) - ↑(harmonic (N + 1 + 1)) + 1

tactic: simp_rw [term_sum, Finset.sum_range_zero, harmonic_succ, harmonic_zero,
  Nat.cast_zero, zero_add, Nat.cast_one, inv_one, Rat.cast_one, log_one, sub_add_cancel]
state_before: case zero

⊢ term_sum 1 0 = log (↑0 + 1) - ↑(harmonic (0 + 1)) + 1
state_after: no goals

tactic: unfold term_sum at hN ⊢
state_before: case succ
N : ℕ
hN : term_sum 1 N = log (↑N + 1) - ↑(harmonic (N + 1)) + 1
⊢ term_sum 1 (N + 1) = log (↑(N + 1) + 1) - ↑(harmonic (N + 1 + 1)) + 1
state_after: case succ
N : ℕ
hN : ∑ n ∈ Finset.range N, term (n + 1) 1 = log (↑N + 1) - ↑(harmonic (N + 1)) + 1
⊢ ∑ n ∈ Finset.range (N + 1), term (n + 1) 1 = log (↑(N + 1) + 1) - ↑(harmonic (N + 1 + 1)) + 1

tactic: rw [Finset.sum_range_succ, hN, harmonic_succ (N + 1),
  term_one (by positivity : 0 < N + 1)]
state_before: case succ
N : ℕ
hN : ∑ n ∈ Finset.range N, term (n + 1) 1 = log (↑N + 1) - ↑(harmonic (N + 1)) + 1
⊢ ∑ n ∈ Finset.range (N + 1), term (n + 1) 1 = log (↑(N + 1) + 1) - ↑(harmonic (N + 1 + 1)) + 1
state_after: case succ
N : ℕ
hN : ∑ n ∈ Finset.range N, term (n + 1) 1 = log (↑N + 1) - ↑(harmonic (N + 1)) + 1
⊢ log (↑N + 1) - ↑(harmonic (N + 1)) + 1 + (log (↑(N + 1) + 1) - log ↑(N + 1) - 1 / (↑(N + 1) + 1)) =
    log (↑(N + 1) + 1) - ↑(harmonic (N + 1) + (↑(N + 1 + 1))⁻¹) + 1

tactic: push_cast
state_before: case succ
N : ℕ
hN : ∑ n ∈ Finset.range N, term (n + 1) 1 = log (↑N + 1) - ↑(harmonic (N + 1)) + 1
⊢ log (↑N + 1) - ↑(harmonic (N + 1)) + 1 + (log (↑(N + 1) + 1) - log ↑(N + 1) - 1 / (↑(N + 1) + 1)) =
    log (↑(N + 1) + 1) - ↑(harmonic (N + 1) + (↑(N + 1 + 1))⁻¹) + 1
state_after: case succ
N : ℕ
hN : ∑ n ∈ Finset.range N, term (n + 1) 1 = log (↑N + 1) - ↑(harmonic (N + 1)) + 1
⊢ log (↑N + 1) - ↑(harmonic (N + 1)) + 1 + (log (↑N + 1 + 1) - log (↑N + 1) - 1 / (↑N + 1 + 1)) =
    log (↑N + 1 + 1) - (↑(harmonic (N + 1)) + (↑N + 1 + 1)⁻¹) + 1

tactic: ring_nf
state_before: case succ
N : ℕ
hN : ∑ n ∈ Finset.range N, term (n + 1) 1 = log (↑N + 1) - ↑(harmonic (N + 1)) + 1
⊢ log (↑N + 1) - ↑(harmonic (N + 1)) + 1 + (log (↑N + 1 + 1) - log (↑N + 1) - 1 / (↑N + 1 + 1)) =
    log (↑N + 1 + 1) - (↑(harmonic (N + 1)) + (↑N + 1 + 1)⁻¹) + 1
state_after: no goals

tactic: positivity
state_before: N : ℕ
hN : ∑ n ∈ Finset.range N, term (n + 1) 1 = log (↑N + 1) - ↑(harmonic (N + 1)) + 1
⊢ 0 < N + 1
state_after: no goals
Theorem: derivWithin_sub_const
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

tactic: simp only [derivWithin, fderivWithin_sub_const hxs]
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 : Filter 𝕜
hxs : UniqueDiffWithinAt 𝕜 s x
c : F
⊢ derivWithin (fun y => f y - c) s x = derivWithin f s x
state_after: no goals
Theorem: Set.pow_subset_pow_of_one_mem
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: induction' n, hn using Nat.le_induction with _ _ ih
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hs : 1 ∈ s
hn : m ≤ n
⊢ s ^ m ⊆ s ^ n
state_after: case base
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hs : 1 ∈ s
⊢ s ^ m ⊆ s ^ m

case succ
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hs : 1 ∈ s
n✝ : ℕ
hmn✝ : m ≤ n✝
ih : s ^ m ⊆ s ^ n✝
⊢ s ^ m ⊆ s ^ (n✝ + 1)

tactic: exact Subset.rfl
state_before: case base
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hs : 1 ∈ s
⊢ s ^ m ⊆ s ^ m
state_after: no goals

tactic: rw [pow_succ']
state_before: case succ
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hs : 1 ∈ s
n✝ : ℕ
hmn✝ : m ≤ n✝
ih : s ^ m ⊆ s ^ n✝
⊢ s ^ m ⊆ s ^ (n✝ + 1)
state_after: case succ
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hs : 1 ∈ s
n✝ : ℕ
hmn✝ : m ≤ n✝
ih : s ^ m ⊆ s ^ n✝
⊢ s ^ m ⊆ s * s ^ n✝

tactic: exact ih.trans (subset_mul_right _ hs)
state_before: case succ
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hs : 1 ∈ s
n✝ : ℕ
hmn✝ : m ≤ n✝
ih : s ^ m ⊆ s ^ n✝
⊢ s ^ m ⊆ s * s ^ n✝
state_after: no goals