tasksource/leandojo huggingface dataset:
Theorem: exists_seq_norm_le_one_le_norm_sub
File: Mathlib/Analysis/NormedSpace/FiniteDimension.lean

tactic: obtain ⟨c, hc⟩ : ∃ c : 𝕜, 1 < ‖c‖ := NormedField.exists_one_lt_norm 𝕜
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
h : ¬FiniteDimensional 𝕜 E
⊢ ∃ R f, 1 < R ∧ (∀ (n : ℕ), ‖f n‖ ≤ R) ∧ ∀ (m n : ℕ), m ≠ n → 1 ≤ ‖f m - f n‖

tactic: have A : ‖c‖ < ‖c‖ + 1 := by linarith
state_before: case intro
𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
h : ¬FiniteDimensional 𝕜 E
c : 𝕜
hc : 1 < ‖c‖
⊢ ∃ R f, 1 < R ∧ (∀ (n : ℕ), ‖f n‖ ≤ R) ∧ ∀ (m n : ℕ), m ≠ n → 1 ≤ ‖f m - f n‖

tactic: rcases exists_seq_norm_le_one_le_norm_sub' hc A h with ⟨f, hf⟩
state_before: case intro
𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
h : ¬FiniteDimensional 𝕜 E
c : 𝕜
hc : 1 < ‖c‖
A : ‖c‖ < ‖c‖ + 1
⊢ ∃ R f, 1 < R ∧ (∀ (n : ℕ), ‖f n‖ ≤ R) ∧ ∀ (m n : ℕ), m ≠ n → 1 ≤ ‖f m - f n‖

tactic: exact ⟨‖c‖ + 1, f, hc.trans A, hf.1, hf.2⟩
state_before: case intro.intro
𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
h : ¬FiniteDimensional 𝕜 E
c : 𝕜
hc : 1 < ‖c‖
A : ‖c‖ < ‖c‖ + 1
f : ℕ → E
hf : (∀ (n : ℕ), ‖f n‖ ≤ ‖c‖ + 1) ∧ ∀ (m n : ℕ), m ≠ n → 1 ≤ ‖f m - f n‖
⊢ ∃ R f, 1 < R ∧ (∀ (n : ℕ), ‖f n‖ ≤ R) ∧ ∀ (m n : ℕ), m ≠ n → 1 ≤ ‖f m - f n‖

tactic: linarith
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
h : ¬FiniteDimensional 𝕜 E
c : 𝕜
hc : 1 < ‖c‖
⊢ ‖c‖ < ‖c‖ + 1
Theorem: PrimeSpectrum.gc_set
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: have ideal_gc : GaloisConnection Ideal.span _ := (Submodule.gi R R).gc
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ GaloisConnection (fun s => zeroLocus s) fun t => ↑(vanishingIdeal t)

tactic: simpa [zeroLocus_span, Function.comp] using ideal_gc.compose (gc R)
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
ideal_gc : GaloisConnection Ideal.span SetLike.coe
⊢ GaloisConnection (fun s => zeroLocus s) fun t => ↑(vanishingIdeal t)
Theorem: Nat.nine_dvd_iff
File: Mathlib/Data/Nat/Digits.lean

tactic: norm_num
state_before: n✝ n : ℕ
⊢ 10 % 9 = 1
Theorem: Set.exists_ne_map_eq_of_ncard_lt_of_maps_to
File: Mathlib/Data/Set/Ncard.lean

tactic: by_contra h'
state_before: α : Type u_2
β : Type u_1
s t✝ : Set α
a b x y : α
f✝ : α → β
t : Set β
hc : ncard t < ncard s
f : α → β
hf : ∀ (a : α), a ∈ s → f a ∈ t
ht : autoParam (Set.Finite t) _auto✝
⊢ ∃ x, x ∈ s ∧ ∃ y, y ∈ s ∧ x ≠ y ∧ f x = f y

tactic: simp only [Ne.def, exists_prop, not_exists, not_and, not_imp_not] at h'
state_before: α : Type u_2
β : Type u_1
s t✝ : Set α
a b x y : α
f✝ : α → β
t : Set β
hc : ncard t < ncard s
f : α → β
hf : ∀ (a : α), a ∈ s → f a ∈ t
ht : autoParam (Set.Finite t) _auto✝
h' : ¬∃ x, x ∈ s ∧ ∃ y, y ∈ s ∧ x ≠ y ∧ f x = f y
⊢ False

tactic: exact (ncard_le_ncard_of_injOn f hf h' ht).not_lt hc
state_before: α : Type u_2
β : Type u_1
s t✝ : Set α
a b x y : α
f✝ : α → β
t : Set β
hc : ncard t < ncard s
f : α → β
hf : ∀ (a : α), a ∈ s → f a ∈ t
ht : autoParam (Set.Finite t) _auto✝
h' : ∀ (x : α), x ∈ s → ∀ (x_1 : α), x_1 ∈ s → f x = f x_1 → x = x_1
⊢ False
Theorem: IsMaxOn.sub
File: Mathlib/Order/Filter/Extr.lean

tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝ : OrderedAddCommGroup β
f g : α → β
a : α
s : Set α
l : Filter α
hf : IsMaxOn f s a
hg : IsMinOn g s a
⊢ IsMaxOn (fun x => f x - g x) s a
Theorem: finprod_eq_of_bijective
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [← finprod_mem_univ f, ← finprod_mem_univ g]
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.356791
G : Type ?u.356794
M : Type u_3
N : Type ?u.356800
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g✝ : α → M
a b : α
s t : Set α
f : α → M
g : β → M
e : α → β
he₀ : Bijective e
he₁ : ∀ (x : α), f x = g (e x)
⊢ (∏ᶠ (i : α), f i) = ∏ᶠ (j : β), g j

tactic: exact finprod_mem_eq_of_bijOn _ (bijective_iff_bijOn_univ.mp he₀) fun x _ => he₁ x
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.356791
G : Type ?u.356794
M : Type u_3
N : Type ?u.356800
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g✝ : α → M
a b : α
s t : Set α
f : α → M
g : β → M
e : α → β
he₀ : Bijective e
he₁ : ∀ (x : α), f x = g (e x)
⊢ (∏ᶠ (i : α) (_ : i ∈ univ), f i) = ∏ᶠ (i : β) (_ : i ∈ univ), g i
Theorem: Turing.ListBlank.head_map
File: Mathlib/Computability/TuringMachine.lean

tactic: conv => lhs; rw [← ListBlank.cons_head_tail l]
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l : ListBlank Γ
⊢ head (map f l) = PointedMap.f f (head l)

tactic: exact Quotient.inductionOn' l fun a ↦ rfl
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l : ListBlank Γ
⊢ head (map f (cons (head l) (tail l))) = PointedMap.f f (head l)
Theorem: ENNReal.coe_nnreal_eq
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [ENNReal.ofReal, Real.toNNReal_coe]
state_before: α : Type ?u.18923
β : Type ?u.18926
a b c d : ℝ≥0∞
r✝ p q r : ℝ≥0
⊢ ↑r = ENNReal.ofReal ↑r
Theorem: List.foldr_self
File: Std/Data/List/Init/Lemmas.lean

tactic: simp
state_before: α : Type u_1
l : List α
⊢ foldr cons [] l = l
Theorem: AffineSubspace.convex
File: Mathlib/Analysis/Convex/Basic.lean

tactic: intro x hx y hy a b _ _ hab
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.233124
β : Type ?u.233127
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
Q : AffineSubspace 𝕜 E
⊢ Convex 𝕜 ↑Q

tactic: rw [eq_sub_of_add_eq hab, ← AffineMap.lineMap_apply_module]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.233124
β : Type ?u.233127
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
Q : AffineSubspace 𝕜 E
x : E
hx : x ∈ ↑Q
y : E
hy : y ∈ ↑Q
a b : 𝕜
a✝¹ : 0 ≤ a
a✝ : 0 ≤ b
hab : a + b = 1
⊢ a • x + b • y ∈ ↑Q

tactic: exact AffineMap.lineMap_mem b hx hy
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.233124
β : Type ?u.233127
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
Q : AffineSubspace 𝕜 E
x : E
hx : x ∈ ↑Q
y : E
hy : y ∈ ↑Q
a b : 𝕜
a✝¹ : 0 ≤ a
a✝ : 0 ≤ b
hab : a + b = 1
⊢ ↑(AffineMap.lineMap x y) b ∈ ↑Q
Theorem: rank_fin_fun
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: simp [rank_fun']
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.546106
inst✝¹⁴ : Ring K
inst✝¹³ : StrongRankCondition K
inst✝¹² : AddCommGroup V
inst✝¹¹ : Module K V
inst✝¹⁰ : Module.Free K V
inst✝⁹ : AddCommGroup V'
inst✝⁸ : Module K V'
inst✝⁷ : Module.Free K V'
inst✝⁶ : AddCommGroup V₁
inst✝⁵ : Module K V₁
inst✝⁴ : Module.Free K V₁
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module K (φ i)
inst✝¹ : ∀ (i : η), Module.Free K (φ i)
inst✝ : Fintype η
n : ℕ
⊢ Module.rank K (Fin n → K) = ↑n
Theorem: IsAddSubgroup.of_sub
File: Mathlib/Deprecated/Subgroup.lean

tactic: simpa only [sub_eq_add_neg] using sub_mem hx hy
state_before: G : Type ?u.9247
H : Type ?u.9250
A : Type u_1
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set A
zero_mem : 0 ∈ s
sub_mem : ∀ {a b : A}, a ∈ s → b ∈ s → a - b ∈ s
x y : A
hx : x ∈ s
hy : y ∈ s
⊢ x + -y ∈ s
Theorem: List.Chain.sublist
File: Mathlib/Data/List/Chain.lean

tactic: rw [chain_iff_pairwise] at hl⊢
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a b : α
inst✝ : IsTrans α R
hl : Chain R a l₂
h : l₁ <+ l₂
⊢ Chain R a l₁

tactic: exact hl.sublist (h.cons_cons a)
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a b : α
inst✝ : IsTrans α R
hl : Pairwise R (a :: l₂)
h : l₁ <+ l₂
⊢ Pairwise R (a :: l₁)
Theorem: Matrix.SpecialLinearGroup.SL2_inv_expl
File: Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean

tactic: ext
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type ?u.739651
inst✝ : CommRing S
A : SL(2, R)
⊢ A⁻¹ =
    { val := ![![↑A 1 1, -↑A 0 1], ![-↑A 1 0, ↑A 0 0]],
      property := (_ : det ![![↑A 1 1, -↑A 0 1], ![-↑A 1 0, ↑A 0 0]] = 1) }

tactic: have := Matrix.adjugate_fin_two A.1
state_before: case a
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type ?u.739651
inst✝ : CommRing S
A : SL(2, R)
i✝ j✝ : Fin 2
⊢ ↑A⁻¹ i✝ j✝ =
    ↑{ val := ![![↑A 1 1, -↑A 0 1], ![-↑A 1 0, ↑A 0 0]],
          property := (_ : det ![![↑A 1 1, -↑A 0 1], ![-↑A 1 0, ↑A 0 0]] = 1) }
      i✝ j✝

tactic: rw [coe_inv, this]
state_before: case a
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type ?u.739651
inst✝ : CommRing S
A : SL(2, R)
i✝ j✝ : Fin 2
this : adjugate ↑A = ↑of ![![↑A 1 1, -↑A 0 1], ![-↑A 1 0, ↑A 0 0]]
⊢ ↑A⁻¹ i✝ j✝ =
    ↑{ val := ![![↑A 1 1, -↑A 0 1], ![-↑A 1 0, ↑A 0 0]],
          property := (_ : det ![![↑A 1 1, -↑A 0 1], ![-↑A 1 0, ↑A 0 0]] = 1) }
      i✝ j✝

tactic: rfl
state_before: case a
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type ?u.739651
inst✝ : CommRing S
A : SL(2, R)
i✝ j✝ : Fin 2
this : adjugate ↑A = ↑of ![![↑A 1 1, -↑A 0 1], ![-↑A 1 0, ↑A 0 0]]
⊢ ↑of ![![↑A 1 1, -↑A 0 1], ![-↑A 1 0, ↑A 0 0]] i✝ j✝ =
    ↑{ val := ![![↑A 1 1, -↑A 0 1], ![-↑A 1 0, ↑A 0 0]],
          property := (_ : det ![![↑A 1 1, -↑A 0 1], ![-↑A 1 0, ↑A 0 0]] = 1) }
      i✝ j✝
Theorem: CategoryTheory.Limits.Multicofork.condition
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

tactic: rw [← K.snd_app_right, ← K.fst_app_right]
state_before: C : Type u
inst✝ : Category C
I : MultispanIndex C
K : Multicofork I
a : I.L
⊢ MultispanIndex.fst I a ≫ π K (MultispanIndex.fstFrom I a) = MultispanIndex.snd I a ≫ π K (MultispanIndex.sndFrom I a)
Theorem: SemilatticeInf.ext_inf
File: Mathlib/Order/Lattice.lean

tactic: simp only [le_inf_iff]
state_before: α✝ : Type u
β : Type v
inst✝ : SemilatticeInf α✝
a b c✝ d : α✝
α : Type u_1
A B : SemilatticeInf α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
x y c : α
⊢ c ≤ x ⊓ y ↔ c ≤ x ⊓ y

tactic: rw [← H, @le_inf_iff α A, H, H]
state_before: α✝ : Type u
β : Type v
inst✝ : SemilatticeInf α✝
a b c✝ d : α✝
α : Type u_1
A B : SemilatticeInf α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
x y c : α
⊢ c ≤ x ⊓ y ↔ c ≤ x ∧ c ≤ y
Theorem: Codisjoint.map
File: Mathlib/Order/Hom/Lattice.lean

tactic: rw [codisjoint_iff, ← map_sup, h.eq_top, map_top]
state_before: F : Type u_3
ι : Type ?u.29958
α : Type u_1
β : Type u_2
γ : Type ?u.29967
δ : Type ?u.29970
inst✝⁴ : Lattice α
inst✝³ : BoundedOrder α
inst✝² : Lattice β
inst✝¹ : BoundedOrder β
inst✝ : BoundedLatticeHomClass F α β
f : F
a b : α
h : Codisjoint a b
⊢ Codisjoint (↑f a) (↑f b)
Theorem: dense_compl_singleton_iff_not_open
File: Mathlib/Topology/Basic.lean

tactic: constructor
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
x : α
⊢ Dense ({x}ᶜ) ↔ ¬IsOpen {x}

tactic: intro hd ho
state_before: case mp
α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
x : α
⊢ Dense ({x}ᶜ) → ¬IsOpen {x}

tactic: exact (hd.inter_open_nonempty _ ho (singleton_nonempty _)).ne_empty (inter_compl_self _)
state_before: case mp
α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
x : α
hd : Dense ({x}ᶜ)
ho : IsOpen {x}
⊢ False

tactic: refine' fun ho => dense_iff_inter_open.2 fun U hU hne => inter_compl_nonempty_iff.2 fun hUx => _
state_before: case mpr
α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
x : α
⊢ ¬IsOpen {x} → Dense ({x}ᶜ)

tactic: obtain rfl : U = {x}
state_before: case mpr
α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
x : α
ho : ¬IsOpen {x}
U : Set α
hU : IsOpen U
hne : Set.Nonempty U
hUx : U ⊆ {x}
⊢ False

tactic: exact eq_singleton_iff_nonempty_unique_mem.2 ⟨hne, hUx⟩
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
x : α
ho : ¬IsOpen {x}
U : Set α
hU : IsOpen U
hne : Set.Nonempty U
hUx : U ⊆ {x}
⊢ U = {x}

case mpr
α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
x : α
ho : ¬IsOpen {x}
hU : IsOpen {x}
hne : Set.Nonempty {x}
hUx : {x} ⊆ {x}
⊢ False

tactic: exact ho hU
state_before: case mpr
α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
x : α
ho : ¬IsOpen {x}
hU : IsOpen {x}
hne : Set.Nonempty {x}
hUx : {x} ⊆ {x}
⊢ False
Theorem: Set.right_mem_Icc
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: simp [le_refl]
state_before: α : Type u_1
β : Type ?u.5251
inst✝ : Preorder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ b ∈ Icc a b ↔ a ≤ b
Theorem: Int.le_induction_down
File: Mathlib/Data/Int/Order/Basic.lean

tactic: refine Int.inductionOn' n m ?_ ?_ ?_
state_before: P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), n ≤ m → P n → P (n - 1)
n : ℤ
⊢ n ≤ m → P n

tactic: intro
state_before: case refine_1
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), n ≤ m → P n → P (n - 1)
n : ℤ
⊢ m ≤ m → P m

tactic: exact h0
state_before: case refine_1
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), n ≤ m → P n → P (n - 1)
n : ℤ
a✝ : m ≤ m
⊢ P m

tactic: intro k hle _ hle'
state_before: case refine_2
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), n ≤ m → P n → P (n - 1)
n : ℤ
⊢ ∀ (k : ℤ), m ≤ k → (k ≤ m → P k) → k + 1 ≤ m → P (k + 1)

tactic: exfalso
state_before: case refine_2
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), n ≤ m → P n → P (n - 1)
n k : ℤ
hle : m ≤ k
a✝ : k ≤ m → P k
hle' : k + 1 ≤ m
⊢ P (k + 1)

tactic: exact lt_irrefl k (add_one_le_iff.mp (hle'.trans hle))
state_before: case refine_2.h
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), n ≤ m → P n → P (n - 1)
n k : ℤ
hle : m ≤ k
a✝ : k ≤ m → P k
hle' : k + 1 ≤ m
⊢ False

tactic: intro k hle hi _
state_before: case refine_3
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), n ≤ m → P n → P (n - 1)
n : ℤ
⊢ ∀ (k : ℤ), k ≤ m → (k ≤ m → P k) → k - 1 ≤ m → P (k - 1)

tactic: exact h1 k hle (hi hle)
state_before: case refine_3
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), n ≤ m → P n → P (n - 1)
n k : ℤ
hle : k ≤ m
hi : k ≤ m → P k
a✝ : k - 1 ≤ m
⊢ P (k - 1)
Theorem: Continuous.closure_preimage_subset
File: Mathlib/Topology/Basic.lean

tactic: rw [← (isClosed_closure.preimage hf).closure_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.171989
δ : Type ?u.171992
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
hf : Continuous f
t : Set β
⊢ closure (f ⁻¹' t) ⊆ f ⁻¹' closure t

tactic: exact closure_mono (preimage_mono subset_closure)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.171989
δ : Type ?u.171992
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
hf : Continuous f
t : Set β
⊢ closure (f ⁻¹' t) ⊆ closure (f ⁻¹' closure t)
Theorem: LinearMap.eqLocus_same
File: Mathlib/LinearAlgebra/Basic.lean

tactic: simp only [mem_eqLocus, mem_top]
state_before: R : Type u_1
R₁ : Type ?u.1134796
R₂ : Type u_2
R₃ : Type ?u.1134802
R₄ : Type ?u.1134805
S : Type ?u.1134808
K : Type ?u.1134811
K₂ : Type ?u.1134814
M : Type u_3
M' : Type ?u.1134820
M₁ : Type ?u.1134823
M₂ : Type u_4
M₃ : Type ?u.1134829
M₄ : Type ?u.1134832
N : Type ?u.1134835
N₂ : Type ?u.1134838
ι : Type ?u.1134841
V : Type ?u.1134844
V₂ : Type ?u.1134847
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.1135257
sc : SemilinearMapClass F τ₁₂ M M₂
f : M →ₛₗ[τ₁₂] M₂
x✝ : M
⊢ x✝ ∈ eqLocus f f ↔ x✝ ∈ ⊤
Theorem: Pmf.toOuterMeasure_uniformOfFinset_apply
File: Mathlib/Probability/ProbabilityMassFunction/Uniform.lean

tactic: simp_rw [uniformOfFinset_apply, and_comm, ← ite_and, and_comm]
state_before: α : Type u_1
β : Type ?u.9058
γ : Type ?u.9061
s : Finset α
hs : Finset.Nonempty s
a : α
t : Set α
x : α
⊢ (if x ∈ t then ↑(uniformOfFinset s hs) x else 0) = if x ∈ s ∧ x ∈ t then (↑(Finset.card s))⁻¹ else 0

tactic: let this : x ∈ s ∧ x ∈ t := by simpa using hx
state_before: α : Type u_1
β : Type ?u.9058
γ : Type ?u.9061
s : Finset α
hs : Finset.Nonempty s
a : α
t : Set α
x : α
hx : x ∈ Finset.filter (fun x => x ∈ t) s
⊢ (if x ∈ s ∧ x ∈ t then (↑(Finset.card s))⁻¹ else 0) = (↑(Finset.card s))⁻¹

tactic: simp only [this, and_self_iff, if_true]
state_before: α : Type u_1
β : Type ?u.9058
γ : Type ?u.9061
s : Finset α
hs : Finset.Nonempty s
a : α
t : Set α
x : α
hx : x ∈ Finset.filter (fun x => x ∈ t) s
this : x ∈ s ∧ x ∈ t := Eq.mp Mathlib.Data.Finset.Basic._auxLemma.130 hx
⊢ (if x ∈ s ∧ x ∈ t then (↑(Finset.card s))⁻¹ else 0) = (↑(Finset.card s))⁻¹

tactic: simpa using hx
state_before: α : Type u_1
β : Type ?u.9058
γ : Type ?u.9061
s : Finset α
hs : Finset.Nonempty s
a : α
t : Set α
x : α
hx : x ∈ Finset.filter (fun x => x ∈ t) s
⊢ x ∈ s ∧ x ∈ t

tactic: simp only [div_eq_mul_inv, Finset.sum_const, nsmul_eq_mul]
state_before: α : Type u_1
β : Type ?u.9058
γ : Type ?u.9061
s : Finset α
hs : Finset.Nonempty s
a : α
t : Set α
⊢ ∑ _x in Finset.filter (fun x => x ∈ t) s, (↑(Finset.card s))⁻¹ =
    ↑(Finset.card (Finset.filter (fun x => x ∈ t) s)) / ↑(Finset.card s)
Theorem: Irrational.neg
File: Mathlib/Data/Real/Irrational.lean

tactic: rwa [neg_neg]
state_before: q : ℚ
x y : ℝ
h : Irrational x
⊢ Irrational (- -x)
Theorem: Set.sigma_univ_range_eq
File: Mathlib/Data/Set/Sigma.lean

tactic: simp [range]
state_before: ι : Type u_1
ι' : Type ?u.14429
α : ι → Type u_3
β : ι → Type u_2
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a : α i
f : (i : ι) → α i → β i
⊢ ∀ (x : (i : ι) × β i),
    (x ∈ Set.Sigma univ fun i => range (f i)) ↔ x ∈ range fun x => { fst := x.fst, snd := f x.fst x.snd }
Theorem: Nat.preimage_Ico
File: Mathlib/Algebra/Order/Floor.lean

tactic: ext
state_before: F : Type ?u.63320
α : Type u_1
β : Type ?u.63326
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
⊢ Nat.cast ⁻¹' Ico a b = Ico ⌈a⌉₊ ⌈b⌉₊

tactic: simp [ceil_le, lt_ceil]
state_before: case h
F : Type ?u.63320
α : Type u_1
β : Type ?u.63326
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
x✝ : ℕ
⊢ x✝ ∈ Nat.cast ⁻¹' Ico a b ↔ x✝ ∈ Ico ⌈a⌉₊ ⌈b⌉₊
Theorem: ZMod.val_eq_zero
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [Fin.ext_iff]
state_before: n : ℕ
a : ZMod (n + 1)
⊢ val a = 0 ↔ a = 0

tactic: exact Iff.rfl
state_before: n : ℕ
a : ZMod (n + 1)
⊢ val a = 0 ↔ ↑a = ↑0
Theorem: Filter.EventuallyLE.isMaxFilter
File: Mathlib/Order/Filter/Extr.lean

tactic: refine' hle.mp (h.mono fun x hf hgf => _)
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
hle : g ≤ᶠ[l] f
hfga : f a = g a
h : IsMaxFilter f l a
⊢ IsMaxFilter g l a

tactic: rw [← hfga]
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
hle : g ≤ᶠ[l] f
hfga : f a = g a
h : IsMaxFilter f l a
x : α
hf : f x ≤ f a
hgf : g x ≤ f x
⊢ g x ≤ g a

tactic: exact le_trans hgf hf
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
hle : g ≤ᶠ[l] f
hfga : f a = g a
h : IsMaxFilter f l a
x : α
hf : f x ≤ f a
hgf : g x ≤ f x
⊢ g x ≤ f a
Theorem: MvPolynomial.eq_zero_iff
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [ext_iff]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q p : MvPolynomial σ R
⊢ p = 0 ↔ ∀ (d : σ →₀ ℕ), coeff d p = 0

tactic: simp only [coeff_zero]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q p : MvPolynomial σ R
⊢ (∀ (m : σ →₀ ℕ), coeff m p = coeff m 0) ↔ ∀ (d : σ →₀ ℕ), coeff d p = 0
Theorem: CategoryTheory.InjectiveResolution.desc_commutes
File: Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean

tactic: ext
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
Y Z : C
f : Z ⟶ Y
I : InjectiveResolution Y
J : InjectiveResolution Z
⊢ J.ι ≫ desc f I J = (CochainComplex.single₀ C).map f ≫ I.ι

tactic: simp [desc, descFOne, descFZero]
state_before: case h
C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
Y Z : C
f : Z ⟶ Y
I : InjectiveResolution Y
J : InjectiveResolution Z
⊢ HomologicalComplex.Hom.f (J.ι ≫ desc f I J) 0 = HomologicalComplex.Hom.f ((CochainComplex.single₀ C).map f ≫ I.ι) 0
Theorem: SimpleGraph.simpleGraphOfStructure
File: Mathlib/ModelTheory/Graph.lean

tactic: ext
state_before: L : Language
α : Type w
V : Type w'
n : ℕ
G : SimpleGraph V
⊢ FirstOrder.Language.simpleGraphOfStructure V = G

tactic: rfl
state_before: case Adj.h.h.a
L : Language
α : Type w
V : Type w'
n : ℕ
G : SimpleGraph V
x✝¹ x✝ : V
⊢ SimpleGraph.Adj (FirstOrder.Language.simpleGraphOfStructure V) x✝¹ x✝ ↔ SimpleGraph.Adj G x✝¹ x✝
Theorem: Disjoint.le_symmDiff_sup_symmDiff_left
File: Mathlib/Order/SymmDiff.lean

tactic: trans c \ (a ⊓ b)
state_before: ι : Type ?u.93896
α : Type u_1
β : Type ?u.93902
π : ι → Type ?u.93907
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint a b
⊢ c ≤ a ∆ c ⊔ b ∆ c

tactic: rw [h.eq_bot, sdiff_bot]
state_before: ι : Type ?u.93896
α : Type u_1
β : Type ?u.93902
π : ι → Type ?u.93907
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint a b
⊢ c ≤ c \ (a ⊓ b)

tactic: rw [sdiff_inf]
state_before: ι : Type ?u.93896
α : Type u_1
β : Type ?u.93902
π : ι → Type ?u.93907
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint a b
⊢ c \ (a ⊓ b) ≤ a ∆ c ⊔ b ∆ c

tactic: exact sup_le_sup le_sup_right le_sup_right
state_before: ι : Type ?u.93896
α : Type u_1
β : Type ?u.93902
π : ι → Type ?u.93907
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint a b
⊢ c \ a ⊔ c \ b ≤ a ∆ c ⊔ b ∆ c
Theorem: Set.Finite.toFinset_image
File: Mathlib/Data/Set/Finite.lean

tactic: ext
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs✝ : Set.Finite s
ht : Set.Finite t
inst✝ : DecidableEq β
f : α → β
hs : Set.Finite s
h : Set.Finite (f '' s)
⊢ Finite.toFinset h = Finset.image f (Finite.toFinset hs)

tactic: simp
state_before: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs✝ : Set.Finite s
ht : Set.Finite t
inst✝ : DecidableEq β
f : α → β
hs : Set.Finite s
h : Set.Finite (f '' s)
a✝ : β
⊢ a✝ ∈ Finite.toFinset h ↔ a✝ ∈ Finset.image f (Finite.toFinset hs)