tasksource/leandojo huggingface dataset:
Theorem: Function.update_exp
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: ext i
state_before: 𝕂 : Type u_3
𝔸✝ : Type ?u.766093
𝔹 : Type ?u.766096
inst✝¹⁰ : IsROrC 𝕂
inst✝⁹ : NormedRing 𝔸✝
inst✝⁸ : NormedAlgebra 𝕂 𝔸✝
inst✝⁷ : NormedRing 𝔹
inst✝⁶ : NormedAlgebra 𝕂 𝔹
inst✝⁵ : CompleteSpace 𝔸✝
ι : Type u_1
𝔸 : ι → Type u_2
inst✝⁴ : Fintype ι
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → NormedRing (𝔸 i)
inst✝¹ : (i : ι) → NormedAlgebra 𝕂 (𝔸 i)
inst✝ : ∀ (i : ι), CompleteSpace (𝔸 i)
x : (i : ι) → 𝔸 i
j : ι
xj : 𝔸 j
⊢ update (exp 𝕂 x) j (exp 𝕂 xj) = exp 𝕂 (update x j xj)

tactic: simp_rw [Pi.exp_def]
state_before: case h
𝕂 : Type u_3
𝔸✝ : Type ?u.766093
𝔹 : Type ?u.766096
inst✝¹⁰ : IsROrC 𝕂
inst✝⁹ : NormedRing 𝔸✝
inst✝⁸ : NormedAlgebra 𝕂 𝔸✝
inst✝⁷ : NormedRing 𝔹
inst✝⁶ : NormedAlgebra 𝕂 𝔹
inst✝⁵ : CompleteSpace 𝔸✝
ι : Type u_1
𝔸 : ι → Type u_2
inst✝⁴ : Fintype ι
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → NormedRing (𝔸 i)
inst✝¹ : (i : ι) → NormedAlgebra 𝕂 (𝔸 i)
inst✝ : ∀ (i : ι), CompleteSpace (𝔸 i)
x : (i : ι) → 𝔸 i
j : ι
xj : 𝔸 j
i : ι
⊢ update (exp 𝕂 x) j (exp 𝕂 xj) i = exp 𝕂 (update x j xj) i

tactic: exact (Function.apply_update (fun i => exp 𝕂) x j xj i).symm
state_before: case h
𝕂 : Type u_3
𝔸✝ : Type ?u.766093
𝔹 : Type ?u.766096
inst✝¹⁰ : IsROrC 𝕂
inst✝⁹ : NormedRing 𝔸✝
inst✝⁸ : NormedAlgebra 𝕂 𝔸✝
inst✝⁷ : NormedRing 𝔹
inst✝⁶ : NormedAlgebra 𝕂 𝔹
inst✝⁵ : CompleteSpace 𝔸✝
ι : Type u_1
𝔸 : ι → Type u_2
inst✝⁴ : Fintype ι
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → NormedRing (𝔸 i)
inst✝¹ : (i : ι) → NormedAlgebra 𝕂 (𝔸 i)
inst✝ : ∀ (i : ι), CompleteSpace (𝔸 i)
x : (i : ι) → 𝔸 i
j : ι
xj : 𝔸 j
i : ι
⊢ update (fun i => exp 𝕂 (x i)) j (exp 𝕂 xj) i = exp 𝕂 (update x j xj i)
Theorem: Set.image2_left
File: Mathlib/Data/Set/NAry.lean

tactic: simp [nonempty_def.mp h, ext_iff]
state_before: α : Type u_2
α' : Type ?u.35154
β : Type u_1
β' : Type ?u.35160
γ : Type ?u.35163
γ' : Type ?u.35166
δ : Type ?u.35169
δ' : Type ?u.35172
ε : Type ?u.35175
ε' : Type ?u.35178
ζ : Type ?u.35181
ζ' : Type ?u.35184
ν : Type ?u.35187
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
h : Set.Nonempty t
⊢ image2 (fun x x_1 => x) s t = s
Theorem: MeasureTheory.Measure.haar.is_left_invariant_prehaar
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: simp only [prehaar, Compacts.coe_map, is_left_invariant_index K.isCompact _ hU]
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : Set.Nonempty (interior U)
g : G
K : Compacts G
⊢ prehaar (↑K₀) U (Compacts.map (fun b => g * b) (_ : Continuous fun b => g * b) K) = prehaar (↑K₀) U K
Theorem: Set.iUnionLift_const
File: Mathlib/Data/Set/UnionLift.lean

tactic: let ⟨i, hi⟩ := Set.mem_iUnion.1 (hT c.prop)
state_before: α : Type u_1
ι : Sort u_3
β : Sort u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf :
  ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j),
    f i { val := x, property := hxi } = f j { val := x, property := hxj }
T : Set α
hT : T ⊆ iUnion S
hT' : T = iUnion S
c : ↑T
ci : (i : ι) → ↑(S i)
hci : ∀ (i : ι), ↑(ci i) = ↑c
cβ : β
h : ∀ (i : ι), f i (ci i) = cβ
⊢ iUnionLift S f hf T hT c = cβ

tactic: have : ci i = ⟨c, hi⟩ := Subtype.ext (hci i)
state_before: α : Type u_1
ι : Sort u_3
β : Sort u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf :
  ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j),
    f i { val := x, property := hxi } = f j { val := x, property := hxj }
T : Set α
hT : T ⊆ iUnion S
hT' : T = iUnion S
c : ↑T
ci : (i : ι) → ↑(S i)
hci : ∀ (i : ι), ↑(ci i) = ↑c
cβ : β
h : ∀ (i : ι), f i (ci i) = cβ
i : ι
hi : ↑c ∈ S i
⊢ iUnionLift S f hf T hT c = cβ

tactic: rw [iUnionLift_of_mem _ hi, ← this, h]
state_before: α : Type u_1
ι : Sort u_3
β : Sort u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf :
  ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j),
    f i { val := x, property := hxi } = f j { val := x, property := hxj }
T : Set α
hT : T ⊆ iUnion S
hT' : T = iUnion S
c : ↑T
ci : (i : ι) → ↑(S i)
hci : ∀ (i : ι), ↑(ci i) = ↑c
cβ : β
h : ∀ (i : ι), f i (ci i) = cβ
i : ι
hi : ↑c ∈ S i
this : ci i = { val := ↑c, property := hi }
⊢ iUnionLift S f hf T hT c = cβ
Theorem: Subgroup.singleton_mul_subgroup
File: Mathlib/GroupTheory/Subgroup/Pointwise.lean

tactic: simpa [preimage, mul_mem_cancel_left (inv_mem hh)]
state_before: α : Type ?u.166670
G : Type u_1
A : Type ?u.166676
S : Type ?u.166679
inst✝³ : Group G
inst✝² : AddGroup A
s : Set G
inst✝¹ : Group α
inst✝ : MulDistribMulAction α G
H : Subgroup G
h : G
hh : h ∈ H
this : {x | x ∈ H} = ↑H
⊢ {h} * ↑H = ↑H
Theorem: Disjoint.map_orderIso
File: Mathlib/Order/Hom/Basic.lean

tactic: rw [disjoint_iff_inf_le, ← f.map_inf, ← f.map_bot]
state_before: F : Type ?u.113997
α : Type u_1
β : Type u_2
γ : Type ?u.114006
δ : Type ?u.114009
inst✝³ : SemilatticeInf α
inst✝² : OrderBot α
inst✝¹ : SemilatticeInf β
inst✝ : OrderBot β
a b : α
f : α ≃o β
ha : Disjoint a b
⊢ Disjoint (↑f a) (↑f b)

tactic: exact f.monotone ha.le_bot
state_before: F : Type ?u.113997
α : Type u_1
β : Type u_2
γ : Type ?u.114006
δ : Type ?u.114009
inst✝³ : SemilatticeInf α
inst✝² : OrderBot α
inst✝¹ : SemilatticeInf β
inst✝ : OrderBot β
a b : α
f : α ≃o β
ha : Disjoint a b
⊢ ↑f (a ⊓ b) ≤ ↑f ⊥
Theorem: MvPolynomial.vars_map_of_injective
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: simp [vars, degrees_map_of_injective _ hf]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.221880
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : CommSemiring S
f : R →+* S
hf : Injective ↑f
⊢ vars (↑(map f) p) = vars p
Theorem: Subsingleton.helim
File: src/lean/Init/Core.lean

tactic: subst h₂
state_before: a✝ b✝ c d : Prop
α β : Sort u
h₁ : Subsingleton α
h₂ : α = β
a : α
b : β
⊢ HEq a b

tactic: apply heq_of_eq
state_before: a✝ b✝ c d : Prop
α : Sort u
h₁ : Subsingleton α
a b : α
⊢ HEq a b

tactic: apply Subsingleton.elim
state_before: case h
a✝ b✝ c d : Prop
α : Sort u
h₁ : Subsingleton α
a b : α
⊢ a = b
Theorem: edist_le_of_edist_le_geometric_of_tendsto
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: convert edist_le_tsum_of_edist_le_of_tendsto _ hu ha _
state_before: α : Type u_1
β : Type ?u.431910
ι : Type ?u.431913
inst✝ : PseudoEMetricSpace α
r C : ℝ≥0∞
hr : r < 1
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
⊢ edist (f n) a ≤ C * r ^ n / (1 - r)

tactic: simp only [pow_add, ENNReal.tsum_mul_left, ENNReal.tsum_geometric, div_eq_mul_inv, mul_assoc]
state_before: case h.e'_4
α : Type u_1
β : Type ?u.431910
ι : Type ?u.431913
inst✝ : PseudoEMetricSpace α
r C : ℝ≥0∞
hr : r < 1
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
⊢ C * r ^ n / (1 - r) = ∑' (m : ℕ), C * r ^ (n + m)
Theorem: RatFunc.mk_def_of_mem
File: Mathlib/FieldTheory/RatFunc.lean

tactic: simp only [← mk_coe_def]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
p q : K[X]
hq : q ∈ K[X]⁰
⊢ RatFunc.mk p q = { toFractionRing := IsLocalization.mk' (FractionRing K[X]) p { val := q, property := hq } }
Theorem: SimpleGraph.dartOfNeighborSet_injective
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: injection h with h'
state_before: ι : Sort ?u.99591
𝕜 : Type ?u.99594
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
v : V
e₁ e₂ : ↑(neighborSet G v)
h : dartOfNeighborSet G v e₁ = dartOfNeighborSet G v e₂
⊢ ↑e₁ = ↑e₂

tactic: convert congr_arg Prod.snd h'
state_before: ι : Sort ?u.99591
𝕜 : Type ?u.99594
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
v : V
e₁ e₂ : ↑(neighborSet G v)
h' : (v, ↑e₁) = (v, ↑e₂)
⊢ ↑e₁ = ↑e₂
Theorem: Function.periodicOrbit_eq_nil_iff_not_periodic_pt
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: simp [periodicOrbit]
state_before: α : Type u_1
β : Type ?u.30100
f fa : α → α
fb : β → β
x y : α
m n : ℕ
⊢ periodicOrbit f x = Cycle.nil ↔ ¬x ∈ periodicPts f

tactic: exact minimalPeriod_eq_zero_iff_nmem_periodicPts
state_before: α : Type u_1
β : Type ?u.30100
f fa : α → α
fb : β → β
x y : α
m n : ℕ
⊢ minimalPeriod f x = 0 ↔ ¬x ∈ periodicPts f
Theorem: CategoryTheory.Limits.coprodComparison_natural
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: rw [coprodComparison, coprodComparison, coprod.map_desc, ← F.map_comp, ← F.map_comp,
  coprod.desc_comp, ← F.map_comp, coprod.inl_map, ← F.map_comp, coprod.inr_map]
state_before: C : Type u
inst✝⁵ : Category C
X Y : C
D : Type u₂
inst✝⁴ : Category D
F : C ⥤ D
A A' B B' : C
inst✝³ : HasBinaryCoproduct A B
inst✝² : HasBinaryCoproduct A' B'
inst✝¹ : HasBinaryCoproduct (F.obj A) (F.obj B)
inst✝ : HasBinaryCoproduct (F.obj A') (F.obj B')
f : A ⟶ A'
g : B ⟶ B'
⊢ coprodComparison F A B ≫ F.map (coprod.map f g) = coprod.map (F.map f) (F.map g) ≫ coprodComparison F A' B'
Theorem: Polynomial.aevalTower_id
File: Mathlib/Data/Polynomial/AlgebraMap.lean

tactic: ext s
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type ?u.1573756
B' : Type ?u.1573759
a b : R
n : ℕ
inst✝¹⁰ : CommSemiring A'
inst✝⁹ : Semiring B'
inst✝⁸ : CommSemiring R
p q : R[X]
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
B : Type ?u.1573972
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R B
x : A
inst✝³ : CommSemiring S
inst✝² : Algebra S R
inst✝¹ : Algebra S A'
inst✝ : Algebra S B'
g : R →ₐ[S] A'
y : A'
⊢ aevalTower (AlgHom.id S S) = aeval

tactic: simp only [eval_X, aevalTower_X, coe_aeval_eq_eval]
state_before: case h.h
R : Type u
S : Type v
T : Type w
A : Type z
A' : Type ?u.1573756
B' : Type ?u.1573759
a b : R
n : ℕ
inst✝¹⁰ : CommSemiring A'
inst✝⁹ : Semiring B'
inst✝⁸ : CommSemiring R
p q : R[X]
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
B : Type ?u.1573972
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R B
x : A
inst✝³ : CommSemiring S
inst✝² : Algebra S R
inst✝¹ : Algebra S A'
inst✝ : Algebra S B'
g : R →ₐ[S] A'
y : A'
s : S
⊢ ↑(aevalTower (AlgHom.id S S) s) X = ↑(aeval s) X
Theorem: List.count_concat
File: Mathlib/Data/List/Count.lean

tactic: simp
state_before: α : Type u_1
l✝ : List α
inst✝ : DecidableEq α
a : α
l : List α
⊢ count a (concat l a) = succ (count a l)
Theorem: List.Perm.bind_left
File: Mathlib/Data/List/Perm.lean

tactic: rwa [List.forall₂_map_right_iff, List.forall₂_map_left_iff, List.forall₂_same]
state_before: α : Type uu
β : Type vv
l₁ l₂ l : List α
f g : α → List β
h : ∀ (a : α), a ∈ l → f a ~ g a
⊢ Forall₂ (fun x x_1 => x ~ x_1) (List.map f l) (List.map g l)
Theorem: csSup_inv
File: Mathlib/Algebra/Order/Pointwise.lean

tactic: rw [← image_inv]
state_before: α : Type u_1
inst✝³ : ConditionallyCompleteLattice α
inst✝² : Group α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
s t : Set α
hs₀ : Set.Nonempty s
hs₁ : BddBelow s
⊢ sSup s⁻¹ = (sInf s)⁻¹

tactic: exact ((OrderIso.inv α).map_csInf' hs₀ hs₁).symm
state_before: α : Type u_1
inst✝³ : ConditionallyCompleteLattice α
inst✝² : Group α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
s t : Set α
hs₀ : Set.Nonempty s
hs₁ : BddBelow s
⊢ sSup (Inv.inv '' s) = (sInf s)⁻¹
Theorem: CategoryTheory.Limits.cospanExt_inv_app_left
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: dsimp [cospanExt]
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospanExt iX iY iZ wf wg).inv.app WalkingCospan.left = iX.inv
Theorem: Real.ciSup_empty
File: Mathlib/Data/Real/Basic.lean

tactic: dsimp [iSup]
state_before: x y : ℝ
α : Sort u_1
inst✝ : IsEmpty α
f : α → ℝ
⊢ (⨆ (i : α), f i) = 0

tactic: convert Real.sSup_empty
state_before: x y : ℝ
α : Sort u_1
inst✝ : IsEmpty α
f : α → ℝ
⊢ sSup (Set.range fun i => f i) = 0

tactic: rw [Set.range_eq_empty_iff]
state_before: case h.e'_2.h.e'_3
x y : ℝ
α : Sort u_1
inst✝ : IsEmpty α
f : α → ℝ
⊢ (Set.range fun i => f i) = ∅

tactic: infer_instance
state_before: case h.e'_2.h.e'_3
x y : ℝ
α : Sort u_1
inst✝ : IsEmpty α
f : α → ℝ
⊢ IsEmpty α
Theorem: Ordinal.log_of_not_one_lt_left
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: simp only [log, dif_neg h]
state_before: b : Ordinal
h : ¬1 < b
x : Ordinal
⊢ log b x = 0
Theorem: Prop.isCompl_iff
File: Mathlib/Order/PropInstances.lean

tactic: rw [_root_.isCompl_iff, Prop.disjoint_iff, Prop.codisjoint_iff, not_iff]
state_before: P Q : Prop
⊢ IsCompl P Q ↔ ¬(P ↔ Q)

tactic: by_cases P <;> by_cases Q <;> simp [*]
state_before: P Q : Prop
⊢ ¬(P ∧ Q) ∧ (P ∨ Q) ↔ (¬P ↔ Q)
Theorem: Sym2.card_subtype_diag
File: Mathlib/Data/Sym/Card.lean

tactic: convert card_image_diag (univ : Finset α)
state_before: α : Type u_1
β : Type ?u.80631
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ Fintype.card { a // IsDiag a } = Fintype.card α

tactic: simp_rw [Quotient.mk', ← Quotient.mk''_eq_mk]
state_before: case h.e'_2
α : Type u_1
β : Type ?u.80631
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ Fintype.card { a // IsDiag a } = Finset.card (image Quotient.mk' (Finset.diag univ))

tactic: rw [Fintype.card_of_subtype, ← filter_image_quotient_mk''_isDiag]
state_before: case h.e'_2
α : Type u_1
β : Type ?u.80631
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ Fintype.card { a // IsDiag a } = Finset.card (image (fun a => Quotient.mk'' a) (Finset.diag univ))

tactic: rintro x
state_before: case h.e'_2.H
α : Type u_1
β : Type ?u.80631
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ ∀ (x : Sym2 α), x ∈ filter IsDiag (image Quotient.mk'' (univ ×ˢ univ)) ↔ IsDiag x

tactic: rw [mem_filter, univ_product_univ, mem_image]
state_before: case h.e'_2.H
α : Type u_1
β : Type ?u.80631
inst✝¹ : DecidableEq α
inst✝ : Fintype α
x : Sym2 α
⊢ x ∈ filter IsDiag (image Quotient.mk'' (univ ×ˢ univ)) ↔ IsDiag x

tactic: obtain ⟨a, ha⟩ := Quotient.exists_rep x
state_before: case h.e'_2.H
α : Type u_1
β : Type ?u.80631
inst✝¹ : DecidableEq α
inst✝ : Fintype α
x : Sym2 α
⊢ (∃ a, a ∈ univ ∧ Quotient.mk'' a = x) ∧ IsDiag x ↔ IsDiag x

tactic: exact and_iff_right ⟨a, mem_univ _, ha⟩
state_before: case h.e'_2.H.intro
α : Type u_1
β : Type ?u.80631
inst✝¹ : DecidableEq α
inst✝ : Fintype α
x : Sym2 α
a : α × α
ha : Quotient.mk (Rel.setoid α) a = x
⊢ (∃ a, a ∈ univ ∧ Quotient.mk'' a = x) ∧ IsDiag x ↔ IsDiag x
Theorem: Nat.Partrec.ppred
File: Mathlib/Computability/Partrec.lean

tactic: cases n <;> simp
state_before: this : Primrec₂ fun n m => if n = Nat.succ m then 0 else 1
n : ℕ
⊢ (Nat.rfind fun n_1 =>
      (fun m => decide (m = 0)) <$> ↑(unpaired fun n m => if n = Nat.succ m then 0 else 1) (Nat.pair n n_1)) =
    ↑(Nat.ppred n)

tactic: exact
  eq_none_iff.2 fun a ⟨⟨m, h, _⟩, _⟩ => by
    simp [show 0 ≠ m.succ by intro h; injection h] at h
state_before: case zero
this : Primrec₂ fun n m => if n = Nat.succ m then 0 else 1
⊢ (Nat.rfind fun n => Part.some false) = Part.none

tactic: simp [show 0 ≠ m.succ by intro h; injection h] at h
state_before: this : Primrec₂ fun n m => if n = Nat.succ m then 0 else 1
a : ℕ
x✝ : a ∈ Nat.rfind fun n => Part.some false
m : ℕ
h : true ∈ (fun n => Part.some false) m
right✝ : ∀ (k : ℕ), k < m → ((fun n => Part.some false) k).Dom
h✝ :
  Part.get (Nat.rfind fun n => Part.some false)
      (_ : ∃ n, true ∈ (fun n => Part.some false) n ∧ ∀ (k : ℕ), k < n → ((fun n => Part.some false) k).Dom) =
    a
⊢ False

tactic: intro h
state_before: this : Primrec₂ fun n m => if n = Nat.succ m then 0 else 1
a : ℕ
x✝ : a ∈ Nat.rfind fun n => Part.some false
m : ℕ
h : true ∈ (fun n => Part.some false) m
right✝ : ∀ (k : ℕ), k < m → ((fun n => Part.some false) k).Dom
h✝ :
  Part.get (Nat.rfind fun n => Part.some false)
      (_ : ∃ n, true ∈ (fun n => Part.some false) n ∧ ∀ (k : ℕ), k < n → ((fun n => Part.some false) k).Dom) =
    a
⊢ 0 ≠ Nat.succ m

tactic: injection h
state_before: this : Primrec₂ fun n m => if n = Nat.succ m then 0 else 1
a : ℕ
x✝ : a ∈ Nat.rfind fun n => Part.some false
m : ℕ
h✝¹ : true ∈ (fun n => Part.some false) m
right✝ : ∀ (k : ℕ), k < m → ((fun n => Part.some false) k).Dom
h✝ :
  Part.get (Nat.rfind fun n => Part.some false)
      (_ : ∃ n, true ∈ (fun n => Part.some false) n ∧ ∀ (k : ℕ), k < n → ((fun n => Part.some false) k).Dom) =
    a
h : 0 = Nat.succ m
⊢ False

tactic: refine' eq_some_iff.2 _
state_before: case succ
this : Primrec₂ fun n m => if n = Nat.succ m then 0 else 1
n✝ : ℕ
⊢ (Nat.rfind fun n => Part.some (decide (¬n✝ = n → False))) = Part.some n✝

tactic: simp
state_before: case succ
this : Primrec₂ fun n m => if n = Nat.succ m then 0 else 1
n✝ : ℕ
⊢ n✝ ∈ Nat.rfind fun n => Part.some (decide (¬n✝ = n → False))

tactic: intro m h
state_before: case succ
this : Primrec₂ fun n m => if n = Nat.succ m then 0 else 1
n✝ : ℕ
⊢ ∀ {m : ℕ}, m < n✝ → ¬(¬n✝ = m → False)

tactic: simp [ne_of_gt h]
state_before: case succ
this : Primrec₂ fun n m => if n = Nat.succ m then 0 else 1
n✝ m : ℕ
h : m < n✝
⊢ ¬(¬n✝ = m → False)
Theorem: MvPolynomial.support_rename_of_injective
File: Mathlib/Data/MvPolynomial/Rename.lean

tactic: rw [rename_eq]
state_before: σ : Type u_1
τ : Type u_3
α : Type ?u.1038465
R : Type u_2
S : Type ?u.1038471
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
p : MvPolynomial σ R
f : σ → τ
inst✝ : DecidableEq τ
h : Injective f
⊢ support (↑(rename f) p) = Finset.image (Finsupp.mapDomain f) (support p)

tactic: exact Finsupp.mapDomain_support_of_injective (mapDomain_injective h) _
state_before: σ : Type u_1
τ : Type u_3
α : Type ?u.1038465
R : Type u_2
S : Type ?u.1038471
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
p : MvPolynomial σ R
f : σ → τ
inst✝ : DecidableEq τ
h : Injective f
⊢ support (Finsupp.mapDomain (Finsupp.mapDomain f) p) = Finset.image (Finsupp.mapDomain f) (support p)
Theorem: Finset.preimage_mul_right_singleton
File: Mathlib/Data/Finset/Pointwise.lean

tactic: classical rw [← image_mul_right', image_singleton]
state_before: F : Type ?u.673903
α : Type u_1
β : Type ?u.673909
γ : Type ?u.673912
inst✝ : Group α
s t : Finset α
a b : α
⊢ preimage {b} (fun x => x * a) (_ : Set.InjOn (fun x => x * a) ((fun x => x * a) ⁻¹' ↑{b})) = {b * a⁻¹}

tactic: rw [← image_mul_right', image_singleton]
state_before: F : Type ?u.673903
α : Type u_1
β : Type ?u.673909
γ : Type ?u.673912
inst✝ : Group α
s t : Finset α
a b : α
⊢ preimage {b} (fun x => x * a) (_ : Set.InjOn (fun x => x * a) ((fun x => x * a) ⁻¹' ↑{b})) = {b * a⁻¹}
Theorem: CategoryTheory.Limits.Multicofork.fst_app_right
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

tactic: rw [← K.w (WalkingMultispan.Hom.fst a)]
state_before: C : Type u
inst✝ : Category C
I : MultispanIndex C
K : Multicofork I
a : I.L
⊢ K.ι.app (WalkingMultispan.left a) = MultispanIndex.fst I a ≫ π K (MultispanIndex.fstFrom I a)

tactic: rfl
state_before: C : Type u
inst✝ : Category C
I : MultispanIndex C
K : Multicofork I
a : I.L
⊢ (MultispanIndex.multispan I).map (WalkingMultispan.Hom.fst a) ≫
      K.ι.app (WalkingMultispan.right (MultispanIndex.fstFrom I a)) =
    MultispanIndex.fst I a ≫ π K (MultispanIndex.fstFrom I a)
Theorem: Set.pairwise_union_of_symmetric
File: Mathlib/Data/Set/Pairwise/Basic.lean

tactic: simp only [hr.iff, and_self_iff]
state_before: α : Type u_1
β : Type ?u.9555
γ : Type ?u.9558
ι : Type ?u.9561
ι' : Type ?u.9564
r p q : α → α → Prop
f g : ι → α
s t u : Set α
a b : α
hr : Symmetric r
⊢ (Set.Pairwise s r ∧ Set.Pairwise t r ∧ ∀ (a : α), a ∈ s → ∀ (b : α), b ∈ t → a ≠ b → r a b ∧ r b a) ↔
    Set.Pairwise s r ∧ Set.Pairwise t r ∧ ∀ (a : α), a ∈ s → ∀ (b : α), b ∈ t → a ≠ b → r a b
Theorem: finFunctionFinEquiv_single
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: rw [finFunctionFinEquiv_apply, Fintype.sum_eq_single i, Pi.single_eq_same]
state_before: α : Type ?u.147970
β : Type ?u.147973
m n : ℕ
inst✝ : NeZero m
i : Fin n
j : Fin m
⊢ ↑(↑finFunctionFinEquiv (Pi.single i j)) = ↑j * m ^ ↑i

tactic: rintro x hx
state_before: α : Type ?u.147970
β : Type ?u.147973
m n : ℕ
inst✝ : NeZero m
i : Fin n
j : Fin m
⊢ ∀ (x : Fin n), x ≠ i → ↑(Pi.single i j x) * m ^ ↑x = 0

tactic: rw [Pi.single_eq_of_ne hx, Fin.val_zero, MulZeroClass.zero_mul]
state_before: α : Type ?u.147970
β : Type ?u.147973
m n : ℕ
inst✝ : NeZero m
i : Fin n
j : Fin m
x : Fin n
hx : x ≠ i
⊢ ↑(Pi.single i j x) * m ^ ↑x = 0
Theorem: PowerSeries.coeff_mul_of_lt_order
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: suffices : coeff R n (φ * ψ) = ∑ p in Finset.Nat.antidiagonal n, 0
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
n : ℕ
h : ↑n < order ψ
⊢ ↑(coeff R n) (φ * ψ) = 0

tactic: rw [this, Finset.sum_const_zero]
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
n : ℕ
h : ↑n < order ψ
this : ↑(coeff R n) (φ * ψ) = ∑ p in Finset.Nat.antidiagonal n, 0
⊢ ↑(coeff R n) (φ * ψ) = 0

case this
R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
n : ℕ
h : ↑n < order ψ
⊢ ↑(coeff R n) (φ * ψ) = ∑ p in Finset.Nat.antidiagonal n, 0

tactic: rw [coeff_mul]
state_before: case this
R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
n : ℕ
h : ↑n < order ψ
⊢ ↑(coeff R n) (φ * ψ) = ∑ p in Finset.Nat.antidiagonal n, 0

tactic: apply Finset.sum_congr rfl
state_before: case this
R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
n : ℕ
h : ↑n < order ψ
⊢ ∑ p in Finset.Nat.antidiagonal n, ↑(coeff R p.fst) φ * ↑(coeff R p.snd) ψ = ∑ p in Finset.Nat.antidiagonal n, 0

tactic: intro x hx
state_before: case this
R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
n : ℕ
h : ↑n < order ψ
⊢ ∀ (x : ℕ × ℕ), x ∈ Finset.Nat.antidiagonal n → ↑(coeff R x.fst) φ * ↑(coeff R x.snd) ψ = 0

tactic: refine' mul_eq_zero_of_right (coeff R x.fst φ) (coeff_of_lt_order x.snd (lt_of_le_of_lt _ h))
state_before: case this
R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
n : ℕ
h : ↑n < order ψ
x : ℕ × ℕ
hx : x ∈ Finset.Nat.antidiagonal n
⊢ ↑(coeff R x.fst) φ * ↑(coeff R x.snd) ψ = 0

tactic: rw [Finset.Nat.mem_antidiagonal] at hx
state_before: case this
R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
n : ℕ
h : ↑n < order ψ
x : ℕ × ℕ
hx : x ∈ Finset.Nat.antidiagonal n
⊢ ↑x.snd ≤ ↑n

tactic: norm_cast
state_before: case this
R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
n : ℕ
h : ↑n < order ψ
x : ℕ × ℕ
hx : x.fst + x.snd = n
⊢ ↑x.snd ≤ ↑n

tactic: linarith
state_before: case this
R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
n : ℕ
h : ↑n < order ψ
x : ℕ × ℕ
hx : x.fst + x.snd = n
⊢ x.snd ≤ n
Theorem: selfZpow_neg_mul
File: Mathlib/RingTheory/Localization/Away/Basic.lean

tactic: rw [mul_comm, selfZpow_mul_neg x B d]
state_before: R : Type u_2
inst✝³ : CommRing R
x : R
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
d : ℤ
⊢ selfZpow x B (-d) * selfZpow x B d = 1
Theorem: Set.union_pi
File: Mathlib/Data/Set/Prod.lean

tactic: simp [pi, or_imp, forall_and, setOf_and]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.144565
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
⊢ pi (s₁ ∪ s₂) t = pi s₁ t ∩ pi s₂ t
Theorem: OnePoint.comap_coe_nhds_infty
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: simp [nhds_infty_eq, comap_sup, comap_map coe_injective]
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
⊢ comap some (𝓝 ∞) = coclosedCompact X
Theorem: Bitvec.addLsb_eq_twice_add_one
File: Mathlib/Data/Bitvec/Lemmas.lean

tactic: simp [addLsb, two_mul]
state_before: x : ℕ
b : Bool
⊢ addLsb x b = 2 * x + bif b then 1 else 0
Theorem: Real.sin_lt_sin_of_lt_of_le_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [← cos_sub_pi_div_two, ← cos_sub_pi_div_two, ← cos_neg (x - _), ← cos_neg (y - _)]
state_before: x y : ℝ
hx₁ : -(π / 2) ≤ x
hy₂ : y ≤ π / 2
hxy : x < y
⊢ sin x < sin y

tactic: apply cos_lt_cos_of_nonneg_of_le_pi <;> linarith
state_before: x y : ℝ
hx₁ : -(π / 2) ≤ x
hy₂ : y ≤ π / 2
hxy : x < y
⊢ cos (-(x - π / 2)) < cos (-(y - π / 2))