1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.Integrable.smul_of_top_right
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [← memℒp_one_iff_integrable] at hf ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
φ : α → 𝕜
hf : Integrable f μ
hφ : Memℒp φ ⊤ μ
⊢ Integrable (φ • f) μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
φ : α → 𝕜
hf : Memℒp f 1 μ
hφ : Memℒp φ ⊤ μ
⊢ Memℒp (φ • f) 1 μ

tactic: exact Memℒp.smul_of_top_right hf hφ
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
φ : α → 𝕜
hf : Memℒp f 1 μ
hφ : Memℒp φ ⊤ μ
⊢ Memℒp (φ • f) 1 μ
state_after: no goals
Theorem: csInf_mem_of_not_isPredLimit
File: Mathlib/Order/SuccPred/CompleteLinearOrder.lean

tactic: obtain ⟨y, hy⟩ := not_forall_not.mp hlim
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : ConditionallyCompleteLinearOrder α
inst✝ : Nonempty ι
f : ι → α
s : Set α
x : α
hne : s.Nonempty
hbdd : BddBelow s
hlim : ¬IsPredLimit (sInf s)
⊢ sInf s ∈ s
state_after: case intro
ι : Type u_1
α : Type u_2
inst✝¹ : ConditionallyCompleteLinearOrder α
inst✝ : Nonempty ι
f : ι → α
s : Set α
x : α
hne : s.Nonempty
hbdd : BddBelow s
hlim : ¬IsPredLimit (sInf s)
y : α
hy : sInf s ⋖ y
⊢ sInf s ∈ s

tactic: obtain ⟨i, his, hi⟩ := exists_lt_of_csInf_lt hne hy.lt
state_before: case intro
ι : Type u_1
α : Type u_2
inst✝¹ : ConditionallyCompleteLinearOrder α
inst✝ : Nonempty ι
f : ι → α
s : Set α
x : α
hne : s.Nonempty
hbdd : BddBelow s
hlim : ¬IsPredLimit (sInf s)
y : α
hy : sInf s ⋖ y
⊢ sInf s ∈ s
state_after: case intro.intro.intro
ι : Type u_1
α : Type u_2
inst✝¹ : ConditionallyCompleteLinearOrder α
inst✝ : Nonempty ι
f : ι → α
s : Set α
x : α
hne : s.Nonempty
hbdd : BddBelow s
hlim : ¬IsPredLimit (sInf s)
y : α
hy : sInf s ⋖ y
i : α
his : i ∈ s
hi : i < y
⊢ sInf s ∈ s
Theorem: AlgebraicGeometry.Scheme.OpenCover.fromGlued_openEmbedding
File: Mathlib/AlgebraicGeometry/Gluing.lean

tactic: fun_prop
state_before: X : Scheme
𝒰 : X.OpenCover
⊢ Continuous ⇑𝒰.fromGlued.val.base
state_after: no goals
Theorem: Substring.Valid.nextn
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: let ⟨l, m, r, h⟩ := h.validFor
state_before: m₁ m₂ : List Char
x✝ : Substring
h : x✝.Valid
e : x✝.toString.data = m₁ ++ m₂
⊢ ∀ (n : Nat), x✝.nextn n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + utf8Len (List.take n m₂) }
state_after: m₁ m₂ : List Char
x✝ : Substring
h✝ : x✝.Valid
e : x✝.toString.data = m₁ ++ m₂
l m r : List Char
h : ValidFor l m r x✝
⊢ ∀ (n : Nat), x✝.nextn n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + utf8Len (List.take n m₂) }

tactic: simp only [h.toString] at e
state_before: m₁ m₂ : List Char
x✝ : Substring
h✝ : x✝.Valid
e : x✝.toString.data = m₁ ++ m₂
l m r : List Char
h : ValidFor l m r x✝
⊢ ∀ (n : Nat), x✝.nextn n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + utf8Len (List.take n m₂) }
state_after: m₁ m₂ : List Char
x✝ : Substring
h✝ : x✝.Valid
l m r : List Char
h : ValidFor l m r x✝
e : m = m₁ ++ m₂
⊢ ∀ (n : Nat), x✝.nextn n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + utf8Len (List.take n m₂) }

tactic: subst e
state_before: m₁ m₂ : List Char
x✝ : Substring
h✝ : x✝.Valid
l m r : List Char
h : ValidFor l m r x✝
e : m = m₁ ++ m₂
⊢ ∀ (n : Nat), x✝.nextn n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + utf8Len (List.take n m₂) }
state_after: m₁ m₂ : List Char
x✝ : Substring
h✝ : x✝.Valid
l r : List Char
h : ValidFor l (m₁ ++ m₂) r x✝
⊢ ∀ (n : Nat), x✝.nextn n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + utf8Len (List.take n m₂) }

tactic: simp [h.nextn]
state_before: m₁ m₂ : List Char
x✝ : Substring
h✝ : x✝.Valid
l r : List Char
h : ValidFor l (m₁ ++ m₂) r x✝
⊢ ∀ (n : Nat), x✝.nextn n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + utf8Len (List.take n m₂) }
state_after: no goals
Theorem: Batteries.RBNode.Any_def
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: induction t <;> simp [or_and_right, exists_or, *]
state_before: α : Type u_1
p : α → Prop
t : RBNode α
⊢ Any p t ↔ ∃ x, x ∈ t ∧ p x
state_after: no goals
Theorem: Language.mem_one
File: Mathlib/Computability/Language.lean

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
l m : Language α
a b x✝ x : List α
⊢ x ∈ 1 ↔ x = []
state_after: no goals
Theorem: Set.preimage_eq_iff_eq_image
File: Mathlib/Data/Set/Image.lean

tactic: rw [← image_eq_image hf.1, hf.2.image_preimage]
state_before: α : Type u
β : Type v
f✝ f : α → β
hf : Bijective f
s : Set β
t : Set α
⊢ f ⁻¹' s = t ↔ s = f '' t
state_after: no goals
Theorem: Set.prod_sub_preimage_iff
File: Mathlib/Data/Set/Prod.lean

tactic: simp [subset_def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
W : Set γ
f : α × β → γ
⊢ s ×ˢ t ⊆ f ⁻¹' W ↔ ∀ (a : α) (b : β), a ∈ s → b ∈ t → f (a, b) ∈ W
state_after: no goals
Theorem: SetTheory.PGame.add_lf_add_right
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← PGame.not_le] at h ⊢
state_before: xl xr : Type u
y z : PGame
h : y ⧏ z
x : PGame
this : z + x ≤ y + x → z ≤ y
⊢ y + x ⧏ z + x
state_after: xl xr : Type u
y z : PGame
h : ¬z ≤ y
x : PGame
this : z + x ≤ y + x → z ≤ y
⊢ ¬z + x ≤ y + x

tactic: exact mt this h
state_before: xl xr : Type u
y z : PGame
h : ¬z ≤ y
x : PGame
this : z + x ≤ y + x → z ≤ y
⊢ ¬z + x ≤ y + x
state_after: no goals
Theorem: LSeriesHasSum.neg
File: Mathlib/NumberTheory/LSeries/Linearity.lean

tactic: simpa only [LSeriesHasSum, term_neg] using HasSum.neg hf
state_before: f : ℕ → ℂ
s a : ℂ
hf : LSeriesHasSum f s a
⊢ LSeriesHasSum (-f) s (-a)
state_after: no goals
Theorem: ZMod.ringEquivCongr_intCast
File: Mathlib/Data/ZMod/Basic.lean

tactic: subst h
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : CharP R n
a b : ℕ
h : a = b
z : ℤ
⊢ (ringEquivCongr h) ↑z = ↑z
state_after: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : CharP R n
a : ℕ
z : ℤ
⊢ (ringEquivCongr ⋯) ↑z = ↑z

tactic: cases a <;> rfl
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : CharP R n
a : ℕ
z : ℤ
⊢ (ringEquivCongr ⋯) ↑z = ↑z
state_after: no goals
Theorem: norm_inner_symm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, norm_conj]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ‖⟪x, y⟫_𝕜‖ = ‖⟪y, x⟫_𝕜‖
state_after: no goals
Theorem: MeasureTheory.cylinder_univ
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

tactic: rw [cylinder, preimage_univ]
state_before: ι : Type u_1
α : ι → Type u_2
s : Finset ι
⊢ cylinder s univ = univ
state_after: no goals
Theorem: KaehlerDifferential.kerTotal_mkQ_single_add
File: Mathlib/RingTheory/Kaehler/Basic.lean

tactic: rw [← map_add, eq_comm, ← sub_eq_zero, ← map_sub (Submodule.mkQ (kerTotal R S)),
  Submodule.mkQ_apply, Submodule.Quotient.mk_eq_zero]
state_before: R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
x y z : S
⊢ (z𝖣x + y) = (z𝖣x) + z𝖣y
state_after: R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
x y z : S
⊢ single x z + single y z - single (x + y) z ∈ kerTotal R S

tactic: simp_rw [← Finsupp.smul_single_one _ z, ← smul_add, ← smul_sub]
state_before: R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
x y z : S
⊢ single x z + single y z - single (x + y) z ∈ kerTotal R S
state_after: R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
x y z : S
⊢ z • (single x 1 + single y 1 - single (x + y) 1) ∈ kerTotal R S

tactic: exact Submodule.smul_mem _ _ (Submodule.subset_span (Or.inl <| Or.inl <| ⟨⟨_, _⟩, rfl⟩))
state_before: R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
x y z : S
⊢ z • (single x 1 + single y 1 - single (x + y) 1) ∈ kerTotal R S
state_after: no goals
Theorem: TypeVec.prod_fst_mk
File: Mathlib/Data/TypeVec.lean

tactic: induction' i with _ _ _ i_ih
state_before: n : ℕ
α β : TypeVec.{u_1} n
i : Fin2 n
a : α i
b : β i
⊢ prod.fst i (prod.mk i a b) = a
state_after: case fz
n n✝ : ℕ
α β : TypeVec.{u_1} (n✝ + 1)
a : α Fin2.fz
b : β Fin2.fz
⊢ prod.fst Fin2.fz (prod.mk Fin2.fz a b) = a

case fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α β : TypeVec.{u_1} n✝} (a : α a✝) (b : β a✝), prod.fst a✝ (prod.mk a✝ a b) = a
α β : TypeVec.{u_1} (n✝ + 1)
a : α a✝.fs
b : β a✝.fs
⊢ prod.fst a✝.fs (prod.mk a✝.fs a b) = a

tactic: apply i_ih
state_before: case fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α β : TypeVec.{u_1} n✝} (a : α a✝) (b : β a✝), prod.fst a✝ (prod.mk a✝ a b) = a
α β : TypeVec.{u_1} (n✝ + 1)
a : α a✝.fs
b : β a✝.fs
⊢ prod.fst a✝.fs (prod.mk a✝.fs a b) = a
state_after: no goals

tactic: simp_all only [prod.fst, prod.mk]
state_before: case fz
n n✝ : ℕ
α β : TypeVec.{u_1} (n✝ + 1)
a : α Fin2.fz
b : β Fin2.fz
⊢ prod.fst Fin2.fz (prod.mk Fin2.fz a b) = a
state_after: no goals
Theorem: Finsupp.single_apply_eq_zero
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simp [single_eq_set_indicator]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a✝ a' : α
b✝ : M
a x : α
b : M
⊢ (single a b) x = 0 ↔ x = a → b = 0
state_after: no goals
Theorem: Finset.diag_insert
File: Mathlib/Data/Finset/Prod.lean

tactic: rw [insert_eq, insert_eq, diag_union, diag_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Finset α
x : α × α
a : α
⊢ (insert a s).diag = insert (a, a) s.diag
state_after: no goals
Theorem: EisensteinSeries.auxbound2
File: Mathlib/NumberTheory/ModularForms/EisensteinSeries/UniformConvergence.lean

tactic: have H1 : √(r1 z) ≤ √((c * z.re + d) ^ 2 + (c * z.im) ^ 2) :=
  (Real.sqrt_le_sqrt_iff (by positivity)).mpr (r1_aux_bound _ _ hd)
state_before: z : ℍ
c d : ℝ
hd : 1 ≤ d ^ 2
⊢ r z ≤ Complex.abs (↑c * ↑z + ↑d)
state_after: z : ℍ
c d : ℝ
hd : 1 ≤ d ^ 2
H1 : √(r1 z) ≤ √((c * z.re + d) ^ 2 + (c * z.im) ^ 2)
⊢ r z ≤ Complex.abs (↑c * ↑z + ↑d)

tactic: simpa only [r, abs_apply, normSq_apply, add_re, re_ofReal_mul, coe_re, ofReal_re, ← pow_two,
  add_im, im_ofReal_mul, coe_im, ofReal_im, add_zero, min_le_iff] using Or.inr H1
state_before: z : ℍ
c d : ℝ
hd : 1 ≤ d ^ 2
H1 : √(r1 z) ≤ √((c * z.re + d) ^ 2 + (c * z.im) ^ 2)
⊢ r z ≤ Complex.abs (↑c * ↑z + ↑d)
state_after: no goals

tactic: positivity
state_before: z : ℍ
c d : ℝ
hd : 1 ≤ d ^ 2
⊢ 0 ≤ (c * z.re + d) ^ 2 + (c * z.im) ^ 2
state_after: no goals
Theorem: Filter.map_const
File: Mathlib/Order/Filter/Basic.lean

tactic: ext s
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
inst✝ : f.NeBot
c : β
⊢ map (fun x => c) f = pure c
state_after: case a
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
inst✝ : f.NeBot
c : β
s : Set β
⊢ s ∈ map (fun x => c) f ↔ s ∈ pure c

tactic: by_cases h : c ∈ s <;> simp [h]
state_before: case a
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
inst✝ : f.NeBot
c : β
s : Set β
⊢ s ∈ map (fun x => c) f ↔ s ∈ pure c
state_after: no goals
Theorem: IsCompactOperator.image_subset_compact_of_bounded
File: Mathlib/Analysis/NormedSpace/CompactOperator.lean

tactic: rwa [NormedSpace.isVonNBounded_iff]
state_before: 𝕜₁ : Type u_1
𝕜₂ : Type u_2
inst✝⁷ : NontriviallyNormedField 𝕜₁
inst✝⁶ : SeminormedRing 𝕜₂
σ₁₂ : 𝕜₁ →+* 𝕜₂
M₁ : Type u_3
M₂ : Type u_4
M₃ : Type u_5
inst✝⁵ : SeminormedAddCommGroup M₁
inst✝⁴ : TopologicalSpace M₂
inst✝³ : AddCommMonoid M₂
inst✝² : NormedSpace 𝕜₁ M₁
inst✝¹ : Module 𝕜₂ M₂
inst✝ : ContinuousConstSMul 𝕜₂ M₂
f : M₁ →ₛₗ[σ₁₂] M₂
hf : IsCompactOperator ⇑f
S : Set M₁
hS : Bornology.IsBounded S
⊢ IsVonNBounded 𝕜₁ S
state_after: no goals
Theorem: Set.iUnion_nonempty_self
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [iUnion_nonempty_index, biUnion_self]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set α
⊢ ⋃ (_ : s.Nonempty), s = s
state_after: no goals
Theorem: Finset.inter_empty
File: Mathlib/Data/Finset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ s₁ s₂ t t₁ t₂ u v : Finset α
a b : α
s : Finset α
x✝ : α
⊢ x✝ ∈ s ∧ x✝ ∈ ∅ ↔ x✝ ∈ ∅
state_after: no goals
Theorem: DiscreteQuotient.ofLE_refl
File: Mathlib/Topology/DiscreteQuotient.lean

tactic: ext ⟨⟩
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S A B C : DiscreteQuotient X
⊢ ofLE ⋯ = id
state_after: case h.mk
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S A B C : DiscreteQuotient X
x✝ : Quotient A.toSetoid
a✝ : X
⊢ ofLE ⋯ (Quot.mk Setoid.r a✝) = id (Quot.mk Setoid.r a✝)

tactic: rfl
state_before: case h.mk
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S A B C : DiscreteQuotient X
x✝ : Quotient A.toSetoid
a✝ : X
⊢ ofLE ⋯ (Quot.mk Setoid.r a✝) = id (Quot.mk Setoid.r a✝)
state_after: no goals
Theorem: nhds_basis_closeds
File: Mathlib/Topology/Basic.lean

tactic: simp only [isOpen_compl_iff, mem_compl_iff]
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
x : X
t : Set X
⊢ (∃ x_1, (x ∈ x_1ᶜ ∧ IsOpen x_1ᶜ) ∧ x_1ᶜ ⊆ t) ↔ ∃ i, (x ∉ i ∧ IsClosed i) ∧ iᶜ ⊆ t
state_after: no goals
Theorem: List.mapIdx_eq_enum_map
File: Mathlib/Data/List/Indexes.lean

tactic: rw [List.new_def_eq_old_def]
state_before: α : Type u
β : Type v
l : List α
f : ℕ → α → β
⊢ mapIdx f l = map (uncurry f) l.enum
state_after: α : Type u
β : Type v
l : List α
f : ℕ → α → β
⊢ List.oldMapIdx f l = map (uncurry f) l.enum

tactic: induction' l with hd tl hl generalizing f
state_before: α : Type u
β : Type v
l : List α
f : ℕ → α → β
⊢ List.oldMapIdx f l = map (uncurry f) l.enum
state_after: case nil
α : Type u
β : Type v
f : ℕ → α → β
⊢ List.oldMapIdx f [] = map (uncurry f) [].enum

case cons
α : Type u
β : Type v
hd : α
tl : List α
hl : ∀ (f : ℕ → α → β), List.oldMapIdx f tl = map (uncurry f) tl.enum
f : ℕ → α → β
⊢ List.oldMapIdx f (hd :: tl) = map (uncurry f) (hd :: tl).enum

tactic: rfl
state_before: case nil
α : Type u
β : Type v
f : ℕ → α → β
⊢ List.oldMapIdx f [] = map (uncurry f) [].enum
state_after: no goals

tactic: rw [List.oldMapIdx, List.oldMapIdxCore, List.oldMapIdxCore_eq, hl]
state_before: case cons
α : Type u
β : Type v
hd : α
tl : List α
hl : ∀ (f : ℕ → α → β), List.oldMapIdx f tl = map (uncurry f) tl.enum
f : ℕ → α → β
⊢ List.oldMapIdx f (hd :: tl) = map (uncurry f) (hd :: tl).enum
state_after: case cons
α : Type u
β : Type v
hd : α
tl : List α
hl : ∀ (f : ℕ → α → β), List.oldMapIdx f tl = map (uncurry f) tl.enum
f : ℕ → α → β
⊢ f 0 hd :: map (uncurry fun i a => f (i + (0 + 1)) a) tl.enum = map (uncurry f) (hd :: tl).enum

tactic: simp [map, enum_eq_zip_range, map_uncurry_zip_eq_zipWith]
state_before: case cons
α : Type u
β : Type v
hd : α
tl : List α
hl : ∀ (f : ℕ → α → β), List.oldMapIdx f tl = map (uncurry f) tl.enum
f : ℕ → α → β
⊢ f 0 hd :: map (uncurry fun i a => f (i + (0 + 1)) a) tl.enum = map (uncurry f) (hd :: tl).enum
state_after: no goals
Theorem: SimpleGraph.Walk.support_reverse
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [support_append, *]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
⊢ p.reverse.support = p.support.reverse
state_after: no goals
Theorem: ContT.monadLift_bind
File: Mathlib/Control/Monad/Cont.lean

tactic: ext
state_before: r : Type u
m : Type u → Type v
α✝ β✝ γ ω : Type w
inst✝¹ : Monad m
inst✝ : LawfulMonad m
α β : Type u
x : m α
f : α → m β
⊢ monadLift (x >>= f) = monadLift x >>= monadLift ∘ f
state_after: case h
r : Type u
m : Type u → Type v
α✝ β✝ γ ω : Type w
inst✝¹ : Monad m
inst✝ : LawfulMonad m
α β : Type u
x : m α
f : α → m β
f✝ : β → m r
⊢ (monadLift (x >>= f)).run f✝ = (monadLift x >>= monadLift ∘ f).run f✝
Theorem: List.destutter'_cons_neg
File: Mathlib/Data/List/Destutter.lean

tactic: rw [destutter', if_neg h]
state_before: α : Type u_1
l : List α
R : α → α → Prop
inst✝ : DecidableRel R
a b : α
h : ¬R b a
⊢ destutter' R b (a :: l) = destutter' R b l
state_after: no goals
Theorem: Submonoid.LocalizationMap.eq'
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [f.eq, Localization.r_iff_exists]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
a₁ b₁ : M
a₂ b₂ : ↥S
⊢ f.mk' a₁ a₂ = f.mk' b₁ b₂ ↔ (Localization.r S) (a₁, a₂) (b₁, b₂)
state_after: no goals
Theorem: Nat.le_self_pow
File: Mathlib/Data/Nat/Defs.lean

tactic: simpa using Nat.pow_le_pow_right a.succ_pos (Nat.one_le_iff_ne_zero.2 hn)
state_before: a✝ b c d m n k : ℕ
p q : ℕ → Prop
hn : n ≠ 0
a : ℕ
⊢ a + 1 ≤ (a + 1) ^ n
state_after: no goals
Theorem: List.Sorted.rel_of_mem_take_of_mem_drop
File: Mathlib/Data/List/Sort.lean

tactic: obtain ⟨iy, hiy, rfl⟩ := getElem_of_mem hy
state_before: α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k : ℕ
x y : α
hx : x ∈ take k l
hy : y ∈ drop k l
⊢ r x y
state_after: case intro.intro
α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k : ℕ
x : α
hx : x ∈ take k l
iy : ℕ
hiy : iy < (drop k l).length
hy : (drop k l)[iy] ∈ drop k l
⊢ r x (drop k l)[iy]

tactic: obtain ⟨ix, hix, rfl⟩ := getElem_of_mem hx
state_before: case intro.intro
α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k : ℕ
x : α
hx : x ∈ take k l
iy : ℕ
hiy : iy < (drop k l).length
hy : (drop k l)[iy] ∈ drop k l
⊢ r x (drop k l)[iy]
state_after: case intro.intro.intro.intro
α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k iy : ℕ
hiy : iy < (drop k l).length
hy : (drop k l)[iy] ∈ drop k l
ix : ℕ
hix : ix < (take k l).length
hx : (take k l)[ix] ∈ take k l
⊢ r (take k l)[ix] (drop k l)[iy]

tactic: rw [getElem_take', getElem_drop']
state_before: case intro.intro.intro.intro
α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k iy : ℕ
hiy : iy < (drop k l).length
hy : (drop k l)[iy] ∈ drop k l
ix : ℕ
hix : ix < (take k l).length
hx : (take k l)[ix] ∈ take k l
⊢ r (take k l)[ix] (drop k l)[iy]
state_after: case intro.intro.intro.intro
α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k iy : ℕ
hiy : iy < (drop k l).length
hy : (drop k l)[iy] ∈ drop k l
ix : ℕ
hix : ix < (take k l).length
hx : (take k l)[ix] ∈ take k l
⊢ r l[ix] l[k + iy]

tactic: rw [length_take] at hix
state_before: case intro.intro.intro.intro
α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k iy : ℕ
hiy : iy < (drop k l).length
hy : (drop k l)[iy] ∈ drop k l
ix : ℕ
hix : ix < (take k l).length
hx : (take k l)[ix] ∈ take k l
⊢ r l[ix] l[k + iy]
state_after: case intro.intro.intro.intro
α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k iy : ℕ
hiy : iy < (drop k l).length
hy : (drop k l)[iy] ∈ drop k l
ix : ℕ
hix✝ : ix < (take k l).length
hix : ix < min k l.length
hx : (take k l)[ix] ∈ take k l
⊢ r l[ix] l[k + iy]

tactic: exact h.rel_get_of_lt (Nat.lt_add_right _ (lt_min_iff.mp hix).left)
state_before: case intro.intro.intro.intro
α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k iy : ℕ
hiy : iy < (drop k l).length
hy : (drop k l)[iy] ∈ drop k l
ix : ℕ
hix✝ : ix < (take k l).length
hix : ix < min k l.length
hx : (take k l)[ix] ∈ take k l
⊢ r l[ix] l[k + iy]
state_after: no goals
Theorem: ConvexBody.zero_mem_of_symmetric
File: Mathlib/Analysis/Convex/Body.lean

tactic: obtain ⟨x, hx⟩ := K.nonempty
state_before: V : Type u_1
inst✝² : TopologicalSpace V
inst✝¹ : AddCommGroup V
inst✝ : Module ℝ V
K : ConvexBody V
h_symm : ∀ x ∈ K, -x ∈ K
⊢ 0 ∈ K
state_after: case intro
V : Type u_1
inst✝² : TopologicalSpace V
inst✝¹ : AddCommGroup V
inst✝ : Module ℝ V
K : ConvexBody V
h_symm : ∀ x ∈ K, -x ∈ K
x : V
hx : x ∈ ↑K
⊢ 0 ∈ K

tactic: rw [show 0 = (1/2 : ℝ) • x + (1/2 : ℝ) • (- x) by field_simp]
state_before: case intro
V : Type u_1
inst✝² : TopologicalSpace V
inst✝¹ : AddCommGroup V
inst✝ : Module ℝ V
K : ConvexBody V
h_symm : ∀ x ∈ K, -x ∈ K
x : V
hx : x ∈ ↑K
⊢ 0 ∈ K
state_after: case intro
V : Type u_1
inst✝² : TopologicalSpace V
inst✝¹ : AddCommGroup V
inst✝ : Module ℝ V
K : ConvexBody V
h_symm : ∀ x ∈ K, -x ∈ K
x : V
hx : x ∈ ↑K
⊢ (1 / 2) • x + (1 / 2) • -x ∈ K

tactic: apply convex_iff_forall_pos.mp K.convex hx (h_symm x hx)
state_before: case intro
V : Type u_1
inst✝² : TopologicalSpace V
inst✝¹ : AddCommGroup V
inst✝ : Module ℝ V
K : ConvexBody V
h_symm : ∀ x ∈ K, -x ∈ K
x : V
hx : x ∈ ↑K
⊢ (1 / 2) • x + (1 / 2) • -x ∈ K
state_after: case intro.a
V : Type u_1
inst✝² : TopologicalSpace V
inst✝¹ : AddCommGroup V
inst✝ : Module ℝ V
K : ConvexBody V
h_symm : ∀ x ∈ K, -x ∈ K
x : V
hx : x ∈ ↑K
⊢ 0 < 1 / 2

case intro.a
V : Type u_1
inst✝² : TopologicalSpace V
inst✝¹ : AddCommGroup V
inst✝ : Module ℝ V
K : ConvexBody V
h_symm : ∀ x ∈ K, -x ∈ K
x : V
hx : x ∈ ↑K
⊢ 0 < 1 / 2

case intro.a
V : Type u_1
inst✝² : TopologicalSpace V
inst✝¹ : AddCommGroup V
inst✝ : Module ℝ V
K : ConvexBody V
h_symm : ∀ x ∈ K, -x ∈ K
x : V
hx : x ∈ ↑K
⊢ 1 / 2 + 1 / 2 = 1

tactic: all_goals linarith
state_before: case intro.a
V : Type u_1
inst✝² : TopologicalSpace V
inst✝¹ : AddCommGroup V
inst✝ : Module ℝ V
K : ConvexBody V
h_symm : ∀ x ∈ K, -x ∈ K
x : V
hx : x ∈ ↑K
⊢ 0 < 1 / 2

case intro.a
V : Type u_1
inst✝² : TopologicalSpace V
inst✝¹ : AddCommGroup V
inst✝ : Module ℝ V
K : ConvexBody V
h_symm : ∀ x ∈ K, -x ∈ K
x : V
hx : x ∈ ↑K
⊢ 0 < 1 / 2

case intro.a
V : Type u_1
inst✝² : TopologicalSpace V
inst✝¹ : AddCommGroup V
inst✝ : Module ℝ V
K : ConvexBody V
h_symm : ∀ x ∈ K, -x ∈ K
x : V
hx : x ∈ ↑K
⊢ 1 / 2 + 1 / 2 = 1
state_after: no goals

tactic: field_simp
state_before: V : Type u_1
inst✝² : TopologicalSpace V
inst✝¹ : AddCommGroup V
inst✝ : Module ℝ V
K : ConvexBody V
h_symm : ∀ x ∈ K, -x ∈ K
x : V
hx : x ∈ ↑K
⊢ 0 = (1 / 2) • x + (1 / 2) • -x
state_after: no goals

tactic: linarith
state_before: case intro.a
V : Type u_1
inst✝² : TopologicalSpace V
inst✝¹ : AddCommGroup V
inst✝ : Module ℝ V
K : ConvexBody V
h_symm : ∀ x ∈ K, -x ∈ K
x : V
hx : x ∈ ↑K
⊢ 1 / 2 + 1 / 2 = 1
state_after: no goals
Theorem: CompTriple.comp_apply
File: Mathlib/Logic/Function/CompTypeclasses.lean

tactic: rw [← h.comp_eq, Function.comp_apply]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
φ : M → N
ψ : N → P
χ : M → P
h : CompTriple φ ψ χ
x : M
⊢ ψ (φ x) = χ x
state_after: no goals