1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: List.formPerm_pow_apply_get
File: Mathlib/GroupTheory/Perm/List.lean

tactic: simp [formPerm_pow_apply_getElem, h]
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
n : ℕ
i : Fin l.length
⊢ (l.formPerm ^ n) (l.get i) = l.get ⟨(↑i + n) % l.length, ⋯⟩
state_after: no goals
Theorem: Bornology.IsBounded.cthickening
File: Mathlib/Topology/MetricSpace/Thickening.lean

tactic: have : IsBounded (thickening (max (δ + 1) 1) E) := h.thickening
state_before: ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
δ : ℝ
E : Set α
h : Bornology.IsBounded E
⊢ Bornology.IsBounded (Metric.cthickening δ E)
state_after: ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
δ : ℝ
E : Set α
h : Bornology.IsBounded E
this : Bornology.IsBounded (thickening (max (δ + 1) 1) E)
⊢ Bornology.IsBounded (Metric.cthickening δ E)

tactic: apply this.subset
state_before: ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
δ : ℝ
E : Set α
h : Bornology.IsBounded E
this : Bornology.IsBounded (thickening (max (δ + 1) 1) E)
⊢ Bornology.IsBounded (Metric.cthickening δ E)
state_after: ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
δ : ℝ
E : Set α
h : Bornology.IsBounded E
this : Bornology.IsBounded (thickening (max (δ + 1) 1) E)
⊢ Metric.cthickening δ E ⊆ thickening (max (δ + 1) 1) E

tactic: exact cthickening_subset_thickening' (zero_lt_one.trans_le (le_max_right _ _))
  ((lt_add_one _).trans_le (le_max_left _ _)) _
state_before: ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
δ : ℝ
E : Set α
h : Bornology.IsBounded E
this : Bornology.IsBounded (thickening (max (δ + 1) 1) E)
⊢ Metric.cthickening δ E ⊆ thickening (max (δ + 1) 1) E
state_after: no goals
Theorem: MeasureTheory.Measure.MutuallySingular.restrict_nullSet
File: Mathlib/MeasureTheory/Measure/MutuallySingular.lean

tactic: simp
state_before: α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
h : μ ⟂ₘ ν
⊢ μ.restrict h.nullSet = 0
state_after: no goals
Theorem: Real.sqrt_le_one
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [← sqrt_one, sqrt_le_sqrt_iff zero_le_one, sqrt_one]
state_before: x y : ℝ
⊢ √x ≤ 1 ↔ x ≤ 1
state_after: no goals
Theorem: Submodule.map_inf_eq_map_inf_comap
File: Mathlib/Algebra/Module/Submodule/Map.lean

tactic: rintro _ ⟨⟨x, h₁, rfl⟩, h₂⟩
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
inst✝¹² : Semiring R
inst✝¹¹ : Semiring R₂
inst✝¹⁰ : Semiring R₃
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p✝ p'✝ : Submodule R M
q q' : Submodule R₂ M₂
x : M
F : Type u_9
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F σ₁₂ M M₂
inst✝ : RingHomSurjective σ₁₂
f : F
p : Submodule R M
p' : Submodule R₂ M₂
⊢ map f p ⊓ p' ≤ map f (p ⊓ comap f p')
state_after: case intro.intro.intro
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
inst✝¹² : Semiring R
inst✝¹¹ : Semiring R₂
inst✝¹⁰ : Semiring R₃
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p✝ p'✝ : Submodule R M
q q' : Submodule R₂ M₂
x✝ : M
F : Type u_9
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F σ₁₂ M M₂
inst✝ : RingHomSurjective σ₁₂
f : F
p : Submodule R M
p' : Submodule R₂ M₂
x : M
h₁ : x ∈ ↑p
h₂ : f x ∈ ↑p'
⊢ f x ∈ map f (p ⊓ comap f p')

tactic: exact ⟨_, ⟨h₁, h₂⟩, rfl⟩
state_before: case intro.intro.intro
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
inst✝¹² : Semiring R
inst✝¹¹ : Semiring R₂
inst✝¹⁰ : Semiring R₃
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p✝ p'✝ : Submodule R M
q q' : Submodule R₂ M₂
x✝ : M
F : Type u_9
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F σ₁₂ M M₂
inst✝ : RingHomSurjective σ₁₂
f : F
p : Submodule R M
p' : Submodule R₂ M₂
x : M
h₁ : x ∈ ↑p
h₂ : f x ∈ ↑p'
⊢ f x ∈ map f (p ⊓ comap f p')
state_after: no goals
Theorem: WittVector.ghostFun_pow
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: ghost_fun_tac X 0 ^ m, ![x.coeff]
state_before: p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
x y : 𝕎 R
m : ℕ
⊢ WittVector.ghostFun (x ^ m) = WittVector.ghostFun x ^ m
state_after: no goals
Theorem: Multiset.fold_dedup_idem
File: Mathlib/Data/Multiset/Fold.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
op : α → α → α
hc : Std.Commutative op
ha : Std.Associative op
inst✝ : DecidableEq α
hi : Std.IdempotentOp op
s : Multiset α
b : α
⊢ fold op b (dedup 0) = fold op b 0
state_after: no goals

tactic: by_cases h : a ∈ s <;> simp [IH, h]
state_before: α : Type u_1
β : Type u_2
op : α → α → α
hc : Std.Commutative op
ha : Std.Associative op
inst✝ : DecidableEq α
hi : Std.IdempotentOp op
s✝ : Multiset α
b a : α
s : Multiset α
IH : fold op b s.dedup = fold op b s
⊢ fold op b (a ::ₘ s).dedup = fold op b (a ::ₘ s)
state_after: case pos
α : Type u_1
β : Type u_2
op : α → α → α
hc : Std.Commutative op
ha : Std.Associative op
inst✝ : DecidableEq α
hi : Std.IdempotentOp op
s✝ : Multiset α
b a : α
s : Multiset α
IH : fold op b s.dedup = fold op b s
h : a ∈ s
⊢ fold op b s = op a (fold op b s)

tactic: rw [← cons_erase h, fold_cons_left, ← ha.assoc, hi.idempotent]
state_before: case pos
α : Type u_1
β : Type u_2
op : α → α → α
hc : Std.Commutative op
ha : Std.Associative op
inst✝ : DecidableEq α
hi : Std.IdempotentOp op
s✝ : Multiset α
b a : α
s : Multiset α
IH : fold op b s.dedup = fold op b s
h : a ∈ s
⊢ fold op b s = op a (fold op b s)
state_after: no goals
Theorem: Ideal.span_singleton_eq_top
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: rw [isUnit_iff_dvd_one, ← span_singleton_le_span_singleton, span_singleton_one, eq_top_iff]
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I : Ideal α
x : α
⊢ span {x} = ⊤ ↔ IsUnit x
state_after: no goals
Theorem: norm_inv'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa using norm_div_rev 1 a
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
a : E
⊢ ‖a⁻¹‖ = ‖a‖
state_after: no goals
Theorem: Filter.principal_le_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: simp_rw [le_def, mem_principal]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t s : Set α
f : Filter α
⊢ 𝓟 s ≤ f ↔ ∀ V ∈ f, s ⊆ V
state_after: no goals
Theorem: HasFPowerSeriesOnBall.comp_sub
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: convert hf.hasSum hz using 2
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y z : E
hz : z ∈ EMetric.ball 0 r
⊢ HasSum (fun n => (p n) fun x => z) (f (x + y + z - y))
state_after: case h.e'_6.h.e'_1
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y z : E
hz : z ∈ EMetric.ball 0 r
⊢ x + y + z - y = x + z

tactic: abel
state_before: case h.e'_6.h.e'_1
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y z : E
hz : z ∈ EMetric.ball 0 r
⊢ x + y + z - y = x + z
state_after: no goals
Theorem: Filter.bind_inf_principal
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [mem_bind, mem_inf_principal]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : α → Filter β
s✝ s : Set β
⊢ (s ∈ f.bind fun x => g x ⊓ 𝓟 s✝) ↔ s ∈ f.bind g ⊓ 𝓟 s✝
state_after: no goals
Theorem: Vector.traverse_eq_map_id
File: Mathlib/Data/Vector/Basic.lean

tactic: rintro ⟨x, rfl⟩
state_before: n : ℕ
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α✝ β✝ γ : Type u
α β : Type u_1
f : α → β
⊢ ∀ (x : Vector α n), Vector.traverse (pure ∘ f) x = pure (map f x)
state_after: case mk
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α✝ β✝ γ : Type u
α β : Type u_1
f : α → β
x : List α
⊢ Vector.traverse (pure ∘ f) ⟨x, ⋯⟩ = pure (map f ⟨x, ⋯⟩)

tactic: simp!
state_before: case mk
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α✝ β✝ γ : Type u
α β : Type u_1
f : α → β
x : List α
⊢ Vector.traverse (pure ∘ f) ⟨x, ⋯⟩ = pure (map f ⟨x, ⋯⟩)
state_after: case mk
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α✝ β✝ γ : Type u
α β : Type u_1
f : α → β
x : List α
⊢ Vector.traverseAux (pure ∘ f) x = ⟨List.map f x, ⋯⟩

tactic: induction x <;> simp! [*, functor_norm] <;> rfl
state_before: case mk
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α✝ β✝ γ : Type u
α β : Type u_1
f : α → β
x : List α
⊢ Vector.traverseAux (pure ∘ f) x = ⟨List.map f x, ⋯⟩
state_after: no goals
Theorem: Nat.squarefree_pow_iff
File: Mathlib/Data/Nat/Squarefree.lean

tactic: refine ⟨fun h => ?_, by rintro ⟨hn, rfl⟩; simpa⟩
state_before: s : Finset ℕ
m n✝ p n k : ℕ
hn : n ≠ 1
hk : k ≠ 0
⊢ Squarefree (n ^ k) ↔ Squarefree n ∧ k = 1
state_after: s : Finset ℕ
m n✝ p n k : ℕ
hn : n ≠ 1
hk : k ≠ 0
h : Squarefree (n ^ k)
⊢ Squarefree n ∧ k = 1

tactic: rcases eq_or_ne n 0 with (rfl | -)
state_before: s : Finset ℕ
m n✝ p n k : ℕ
hn : n ≠ 1
hk : k ≠ 0
h : Squarefree (n ^ k)
⊢ Squarefree n ∧ k = 1
state_after: case inl
s : Finset ℕ
m n p k : ℕ
hk : k ≠ 0
hn : 0 ≠ 1
h : Squarefree (0 ^ k)
⊢ Squarefree 0 ∧ k = 1

case inr
s : Finset ℕ
m n✝ p n k : ℕ
hn : n ≠ 1
hk : k ≠ 0
h : Squarefree (n ^ k)
⊢ Squarefree n ∧ k = 1

tactic: refine ⟨h.squarefree_of_dvd (dvd_pow_self _ hk), by_contradiction fun h₁ => ?_⟩
state_before: case inr
s : Finset ℕ
m n✝ p n k : ℕ
hn : n ≠ 1
hk : k ≠ 0
h : Squarefree (n ^ k)
⊢ Squarefree n ∧ k = 1
state_after: case inr
s : Finset ℕ
m n✝ p n k : ℕ
hn : n ≠ 1
hk : k ≠ 0
h : Squarefree (n ^ k)
h₁ : ¬k = 1
⊢ False

tactic: have : 2 ≤ k := k.two_le_iff.mpr ⟨hk, h₁⟩
state_before: case inr
s : Finset ℕ
m n✝ p n k : ℕ
hn : n ≠ 1
hk : k ≠ 0
h : Squarefree (n ^ k)
h₁ : ¬k = 1
⊢ False
state_after: case inr
s : Finset ℕ
m n✝ p n k : ℕ
hn : n ≠ 1
hk : k ≠ 0
h : Squarefree (n ^ k)
h₁ : ¬k = 1
this : 2 ≤ k
⊢ False

tactic: apply hn (Nat.isUnit_iff.1 (h _ _))
state_before: case inr
s : Finset ℕ
m n✝ p n k : ℕ
hn : n ≠ 1
hk : k ≠ 0
h : Squarefree (n ^ k)
h₁ : ¬k = 1
this : 2 ≤ k
⊢ False
state_after: s : Finset ℕ
m n✝ p n k : ℕ
hn : n ≠ 1
hk : k ≠ 0
h : Squarefree (n ^ k)
h₁ : ¬k = 1
this : 2 ≤ k
⊢ n * n ∣ n ^ k

tactic: rw [← sq]
state_before: s : Finset ℕ
m n✝ p n k : ℕ
hn : n ≠ 1
hk : k ≠ 0
h : Squarefree (n ^ k)
h₁ : ¬k = 1
this : 2 ≤ k
⊢ n * n ∣ n ^ k
state_after: s : Finset ℕ
m n✝ p n k : ℕ
hn : n ≠ 1
hk : k ≠ 0
h : Squarefree (n ^ k)
h₁ : ¬k = 1
this : 2 ≤ k
⊢ n ^ 2 ∣ n ^ k

tactic: exact pow_dvd_pow _ this
state_before: s : Finset ℕ
m n✝ p n k : ℕ
hn : n ≠ 1
hk : k ≠ 0
h : Squarefree (n ^ k)
h₁ : ¬k = 1
this : 2 ≤ k
⊢ n ^ 2 ∣ n ^ k
state_after: no goals

tactic: rintro ⟨hn, rfl⟩
state_before: s : Finset ℕ
m n✝ p n k : ℕ
hn : n ≠ 1
hk : k ≠ 0
⊢ Squarefree n ∧ k = 1 → Squarefree (n ^ k)
state_after: case intro
s : Finset ℕ
m n✝ p n : ℕ
hn✝ : n ≠ 1
hn : Squarefree n
hk : 1 ≠ 0
⊢ Squarefree (n ^ 1)

tactic: simpa
state_before: case intro
s : Finset ℕ
m n✝ p n : ℕ
hn✝ : n ≠ 1
hn : Squarefree n
hk : 1 ≠ 0
⊢ Squarefree (n ^ 1)
state_after: no goals

tactic: simp [zero_pow hk] at h
state_before: case inl
s : Finset ℕ
m n p k : ℕ
hk : k ≠ 0
hn : 0 ≠ 1
h : Squarefree (0 ^ k)
⊢ Squarefree 0 ∧ k = 1
state_after: no goals
Theorem: Units.val_div_eq_div_val
File: Mathlib/Algebra/Group/Units.lean

tactic: simp [div_eq_mul_inv]
state_before: α : Type u
inst✝ : DivisionMonoid α
⊢ ∀ (u₁ u₂ : αˣ), ↑(u₁ / u₂) = ↑u₁ / ↑u₂
state_after: no goals
Theorem: Nat.Partrec.Code.curry_inj
File: Mathlib/Computability/PartrecCode.lean

tactic: injection h
state_before: c₁ c₂ : Code
n₁ n₂ : ℕ
h : c₁.curry n₁ = c₂.curry n₂
⊢ c₁ = c₂
state_after: no goals

tactic: injection h with h₁ h₂
state_before: c₁ c₂ : Code
n₁ n₂ : ℕ
h : c₁.curry n₁ = c₂.curry n₂
⊢ n₁ = n₂
state_after: c₁ c₂ : Code
n₁ n₂ : ℕ
h₁ : c₁ = c₂
h₂ : (Code.const n₁).pair Code.id = (Code.const n₂).pair Code.id
⊢ n₁ = n₂

tactic: injection h₂ with h₃ h₄
state_before: c₁ c₂ : Code
n₁ n₂ : ℕ
h₁ : c₁ = c₂
h₂ : (Code.const n₁).pair Code.id = (Code.const n₂).pair Code.id
⊢ n₁ = n₂
state_after: c₁ c₂ : Code
n₁ n₂ : ℕ
h₁ : c₁ = c₂
h₃ : Code.const n₁ = Code.const n₂
h₄ : Code.id = Code.id
⊢ n₁ = n₂

tactic: exact const_inj h₃
state_before: c₁ c₂ : Code
n₁ n₂ : ℕ
h₁ : c₁ = c₂
h₃ : Code.const n₁ = Code.const n₂
h₄ : Code.id = Code.id
⊢ n₁ = n₂
state_after: no goals
Theorem: Filter.lift'_inf
File: Mathlib/Order/Filter/Lift.lean

tactic: rw [inf_eq_iInf, inf_eq_iInf, lift'_iInf hs]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
f g : Filter α
s : Set α → Set β
hs : ∀ (t₁ t₂ : Set α), s (t₁ ∩ t₂) = s t₁ ∩ s t₂
⊢ (f ⊓ g).lift' s = f.lift' s ⊓ g.lift' s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
f g : Filter α
s : Set α → Set β
hs : ∀ (t₁ t₂ : Set α), s (t₁ ∩ t₂) = s t₁ ∩ s t₂
⊢ ⨅ i, (bif i then f else g).lift' s = ⨅ b, bif b then f.lift' s else g.lift' s

tactic: refine iInf_congr ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
f g : Filter α
s : Set α → Set β
hs : ∀ (t₁ t₂ : Set α), s (t₁ ∩ t₂) = s t₁ ∩ s t₂
⊢ ⨅ i, (bif i then f else g).lift' s = ⨅ b, bif b then f.lift' s else g.lift' s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
f g : Filter α
s : Set α → Set β
hs : ∀ (t₁ t₂ : Set α), s (t₁ ∩ t₂) = s t₁ ∩ s t₂
⊢ ∀ (i : Bool), (bif i then f else g).lift' s = bif i then f.lift' s else g.lift' s

tactic: rintro (_|_) <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
f g : Filter α
s : Set α → Set β
hs : ∀ (t₁ t₂ : Set α), s (t₁ ∩ t₂) = s t₁ ∩ s t₂
⊢ ∀ (i : Bool), (bif i then f else g).lift' s = bif i then f.lift' s else g.lift' s
state_after: no goals
Theorem: Rat.zero_mkRat
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

tactic: simp [mkRat_def]
state_before: n : Nat
⊢ mkRat 0 n = 0
state_after: no goals
Theorem: List.forall₂_take
File: Mathlib/Data/List/Forall2.lean

tactic: simp only [Forall₂.nil, take]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
x✝² : List α
x✝¹ : List β
x✝ : Forall₂ R x✝² x✝¹
⊢ Forall₂ R (take 0 x✝²) (take 0 x✝¹)
state_after: no goals

tactic: simp only [Forall₂.nil, take]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
n✝ : ℕ
⊢ Forall₂ R (take (n✝ + 1) []) (take (n✝ + 1) [])
state_after: no goals

tactic: simp [And.intro h₁ h₂, forall₂_take n]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
n : ℕ
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
⊢ Forall₂ R (take (n + 1) (a✝ :: l₁✝)) (take (n + 1) (b✝ :: l₂✝))
state_after: no goals
Theorem: Option.map_bind
File: Mathlib/Data/Option/Basic.lean

tactic: simp only [← map_eq_map, ← bind_pure_comp, LawfulMonad.bind_assoc]
state_before: α✝ : Type u_1
β✝ : Type u_2
γ✝ : Type u_3
δ : Type u_4
p : α✝ → Prop
f✝ : (a : α✝) → p a → β✝
x✝ : Option α✝
α β γ : Type u_5
f : β → γ
x : Option α
g : α → Option β
⊢ Option.map f (x >>= g) = do
    let a ← x
    Option.map f (g a)
state_after: no goals
Theorem: HasProd.prod_range_mul
File: Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean

tactic: refine ((range k).hasProd f).mul_compl ?_
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
k : ℕ
h : HasProd (fun n => f (n + k)) m
⊢ HasProd f ((∏ i ∈ range k, f i) * m)
state_after: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
k : ℕ
h : HasProd (fun n => f (n + k)) m
⊢ HasProd (f ∘ Subtype.val) m

tactic: rwa [← (notMemRangeEquiv k).symm.hasProd_iff]
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
k : ℕ
h : HasProd (fun n => f (n + k)) m
⊢ HasProd (f ∘ Subtype.val) m
state_after: no goals
Theorem: Finset.prod_finset_product_right
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: refine Eq.trans ?_ (prod_sigma s t fun p => f (p.2, p.1))
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✝ : CommMonoid β
r : Finset (α × γ)
s : Finset γ
t : γ → Finset α
h : ∀ (p : α × γ), p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2
f : α × γ → β
⊢ ∏ p ∈ r, f p = ∏ c ∈ s, ∏ a ∈ t c, f (a, c)
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
r : Finset (α × γ)
s : Finset γ
t : γ → Finset α
h : ∀ (p : α × γ), p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2
f : α × γ → β
⊢ ∏ p ∈ r, f p = ∏ x ∈ s.sigma t, f (x.snd, x.fst)

tactic: apply prod_equiv ((Equiv.prodComm _ _).trans (Equiv.sigmaEquivProd _ _).symm) <;> simp [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✝ : CommMonoid β
r : Finset (α × γ)
s : Finset γ
t : γ → Finset α
h : ∀ (p : α × γ), p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2
f : α × γ → β
⊢ ∏ p ∈ r, f p = ∏ x ∈ s.sigma t, f (x.snd, x.fst)
state_after: no goals
Theorem: List.nodup_iff_sublist
File: Mathlib/Data/List/Nodup.lean

tactic: induction' l with a l IH <;> intro h
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
l : List α
⊢ (∀ (a : α), ¬[a, a] <+ l) → l.Nodup
state_after: case nil
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
h : ∀ (a : α), ¬[a, a] <+ []
⊢ [].Nodup

case cons
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b a : α
l : List α
IH : (∀ (a : α), ¬[a, a] <+ l) → l.Nodup
h : ∀ (a_1 : α), ¬[a_1, a_1] <+ a :: l
⊢ (a :: l).Nodup

tactic: exact (IH fun a s => h a <| sublist_cons_of_sublist _ s).cons fun al =>
  h a <| (singleton_sublist.2 al).cons_cons _
state_before: case cons
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b a : α
l : List α
IH : (∀ (a : α), ¬[a, a] <+ l) → l.Nodup
h : ∀ (a_1 : α), ¬[a_1, a_1] <+ a :: l
⊢ (a :: l).Nodup
state_after: no goals

tactic: exact nodup_nil
state_before: case nil
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
h : ∀ (a : α), ¬[a, a] <+ []
⊢ [].Nodup
state_after: no goals
Theorem: abs_mem_iff
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: cases abs_choice x <;> simp [*]
state_before: G✝ : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁶ : Group G✝
inst✝⁵ : Group G'
inst✝⁴ : Group G''
A : Type u_4
inst✝³ : AddGroup A
S : Type u_5
G : Type u_6
inst✝² : AddGroup G
inst✝¹ : LinearOrder G
x✝ : SetLike S G
inst✝ : NegMemClass S G
H : S
x : G
⊢ |x| ∈ H ↔ x ∈ H
state_after: no goals
Theorem: discreteTopology_iff_singleton_mem_nhds
File: Mathlib/Topology/Order.lean

tactic: simp only [← singletons_open_iff_discrete, isOpen_iff_mem_nhds, mem_singleton_iff, forall_eq]
state_before: α : Type u_1
t t₁ t₂ : TopologicalSpace α
s : Set α
inst✝ : TopologicalSpace α
⊢ DiscreteTopology α ↔ ∀ (x : α), {x} ∈ 𝓝 x
state_after: no goals
Theorem: Filter.Tendsto.mul_atBot
File: Mathlib/Topology/Algebra/Order/Field.lean

tactic: simpa only [mul_comm] using hg.atBot_mul hC hf
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
C : 𝕜
hC : 0 < C
hf : Tendsto f l (𝓝 C)
hg : Tendsto g l atBot
⊢ Tendsto (fun x => f x * g x) l atBot
state_after: no goals
Theorem: Set.sdiff_singleton_wcovBy
File: Mathlib/Order/Cover.lean

tactic: by_cases ha : a ∈ s
state_before: α : Type u_1
β : Type u_2
s✝ t : Set α
a✝ : α
s : Set α
a : α
⊢ s \ {a} ⩿ s
state_after: case pos
α : Type u_1
β : Type u_2
s✝ t : Set α
a✝ : α
s : Set α
a : α
ha : a ∈ s
⊢ s \ {a} ⩿ s

case neg
α : Type u_1
β : Type u_2
s✝ t : Set α
a✝ : α
s : Set α
a : α
ha : a ∉ s
⊢ s \ {a} ⩿ s

tactic: convert wcovBy_insert a _
state_before: case pos
α : Type u_1
β : Type u_2
s✝ t : Set α
a✝ : α
s : Set α
a : α
ha : a ∈ s
⊢ s \ {a} ⩿ s
state_after: case h.e'_4
α : Type u_1
β : Type u_2
s✝ t : Set α
a✝ : α
s : Set α
a : α
ha : a ∈ s
⊢ s = insert a (s \ {a})

tactic: ext
state_before: case h.e'_4
α : Type u_1
β : Type u_2
s✝ t : Set α
a✝ : α
s : Set α
a : α
ha : a ∈ s
⊢ s = insert a (s \ {a})
state_after: case h.e'_4.h
α : Type u_1
β : Type u_2
s✝ t : Set α
a✝ : α
s : Set α
a : α
ha : a ∈ s
x✝ : α
⊢ x✝ ∈ s ↔ x✝ ∈ insert a (s \ {a})

tactic: simp [ha]
state_before: case h.e'_4.h
α : Type u_1
β : Type u_2
s✝ t : Set α
a✝ : α
s : Set α
a : α
ha : a ∈ s
x✝ : α
⊢ x✝ ∈ s ↔ x✝ ∈ insert a (s \ {a})
state_after: no goals

tactic: simp [ha]
state_before: case neg
α : Type u_1
β : Type u_2
s✝ t : Set α
a✝ : α
s : Set α
a : α
ha : a ∉ s
⊢ s \ {a} ⩿ s
state_after: no goals
Theorem: ultrafilter_isClosed_basic
File: Mathlib/Topology/StoneCech.lean

tactic: rw [← isOpen_compl_iff]
state_before: α : Type u
s : Set α
⊢ IsClosed {u | s ∈ u}
state_after: α : Type u
s : Set α
⊢ IsOpen {u | s ∈ u}ᶜ

tactic: convert ultrafilter_isOpen_basic sᶜ using 1
state_before: α : Type u
s : Set α
⊢ IsOpen {u | s ∈ u}ᶜ
state_after: case h.e'_3
α : Type u
s : Set α
⊢ {u | s ∈ u}ᶜ = {u | sᶜ ∈ u}

tactic: ext u
state_before: case h.e'_3
α : Type u
s : Set α
⊢ {u | s ∈ u}ᶜ = {u | sᶜ ∈ u}
state_after: case h.e'_3.h
α : Type u
s : Set α
u : Ultrafilter α
⊢ u ∈ {u | s ∈ u}ᶜ ↔ u ∈ {u | sᶜ ∈ u}

tactic: exact Ultrafilter.compl_mem_iff_not_mem.symm
state_before: case h.e'_3.h
α : Type u
s : Set α
u : Ultrafilter α
⊢ u ∈ {u | s ∈ u}ᶜ ↔ u ∈ {u | sᶜ ∈ u}
state_after: no goals
Theorem: interior_Ioc
File: Mathlib/Topology/Order/DenselyOrdered.lean

tactic: rw [← Ioi_inter_Iic, interior_inter, interior_Ioi, interior_Iic, Ioi_inter_Iio]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderTopology α
inst✝¹ : DenselyOrdered α
a✝ b✝ : α
s : Set α
inst✝ : NoMaxOrder α
a b : α
⊢ interior (Ioc a b) = Ioo a b
state_after: no goals