tasksource/leandojo huggingface dataset:
Theorem: multiplicity.pow_prime_pow_sub_pow_prime_pow
File: Mathlib/NumberTheory/Multiplicity.lean

tactic: induction' a with a h_ind
state_before: R : Type u_1
n : ℕ
inst✝² : CommRing R
a✝ b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hxy : ↑p ∣ x - y
hx : ¬↑p ∣ x
a : ℕ
⊢ multiplicity (↑p) (x ^ p ^ a - y ^ p ^ a) = multiplicity (↑p) (x - y) + ↑a

tactic: rw [← Nat.add_one, Nat.cast_add, Nat.cast_one, ← add_assoc, ← h_ind, pow_succ', pow_mul, pow_mul]
state_before: case succ
R : Type u_1
n : ℕ
inst✝² : CommRing R
a✝ b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hxy : ↑p ∣ x - y
hx : ¬↑p ∣ x
a : ℕ
h_ind : multiplicity (↑p) (x ^ p ^ a - y ^ p ^ a) = multiplicity (↑p) (x - y) + ↑a
⊢ multiplicity (↑p) (x ^ p ^ Nat.succ a - y ^ p ^ Nat.succ a) = multiplicity (↑p) (x - y) + ↑(Nat.succ a)

tactic: apply pow_prime_sub_pow_prime hp hp1
state_before: case succ
R : Type u_1
n : ℕ
inst✝² : CommRing R
a✝ b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hxy : ↑p ∣ x - y
hx : ¬↑p ∣ x
a : ℕ
h_ind : multiplicity (↑p) (x ^ p ^ a - y ^ p ^ a) = multiplicity (↑p) (x - y) + ↑a
⊢ multiplicity (↑p) ((x ^ p ^ a) ^ p - (y ^ p ^ a) ^ p) = multiplicity (↑p) (x ^ p ^ a - y ^ p ^ a) + 1

tactic: rw [Nat.cast_zero, add_zero, pow_zero, pow_one, pow_one]
state_before: case zero
R : Type u_1
n : ℕ
inst✝² : CommRing R
a b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hxy : ↑p ∣ x - y
hx : ¬↑p ∣ x
⊢ multiplicity (↑p) (x ^ p ^ Nat.zero - y ^ p ^ Nat.zero) = multiplicity (↑p) (x - y) + ↑Nat.zero

tactic: rw [← geom_sum₂_mul]
state_before: case succ.hxy
R : Type u_1
n : ℕ
inst✝² : CommRing R
a✝ b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hxy : ↑p ∣ x - y
hx : ¬↑p ∣ x
a : ℕ
h_ind : multiplicity (↑p) (x ^ p ^ a - y ^ p ^ a) = multiplicity (↑p) (x - y) + ↑a
⊢ ↑p ∣ x ^ p ^ a - y ^ p ^ a

tactic: exact dvd_mul_of_dvd_right hxy _
state_before: case succ.hxy
R : Type u_1
n : ℕ
inst✝² : CommRing R
a✝ b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hxy : ↑p ∣ x - y
hx : ¬↑p ∣ x
a : ℕ
h_ind : multiplicity (↑p) (x ^ p ^ a - y ^ p ^ a) = multiplicity (↑p) (x - y) + ↑a
⊢ ↑p ∣ (∑ i in range (p ^ a), x ^ i * y ^ (p ^ a - 1 - i)) * (x - y)

tactic: exact fun h => hx (hp.dvd_of_dvd_pow h)
state_before: case succ.hx
R : Type u_1
n : ℕ
inst✝² : CommRing R
a✝ b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hxy : ↑p ∣ x - y
hx : ¬↑p ∣ x
a : ℕ
h_ind : multiplicity (↑p) (x ^ p ^ a - y ^ p ^ a) = multiplicity (↑p) (x - y) + ↑a
⊢ ¬↑p ∣ x ^ p ^ a
Theorem: Set.Definable.image_comp_equiv
File: Mathlib/ModelTheory/Definability.lean

tactic: refine' (congr rfl _).mp (h.preimage_comp f.symm)
state_before: M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type u_1
B : Set M
s✝ : Set (α → M)
s : Set (β → M)
h : Definable A L s
f : α ≃ β
⊢ Definable A L ((fun g => g ∘ ↑f) '' s)

tactic: rw [image_eq_preimage_of_inverse]
state_before: M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type u_1
B : Set M
s✝ : Set (α → M)
s : Set (β → M)
h : Definable A L s
f : α ≃ β
⊢ (fun g => g ∘ ↑f.symm) ⁻¹' s = (fun g => g ∘ ↑f) '' s

tactic: intro i
state_before: case h₁
M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type u_1
B : Set M
s✝ : Set (α → M)
s : Set (β → M)
h : Definable A L s
f : α ≃ β
⊢ Function.LeftInverse (fun g => g ∘ ↑f.symm) fun g => g ∘ ↑f

tactic: ext b
state_before: case h₁
M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type u_1
B : Set M
s✝ : Set (α → M)
s : Set (β → M)
h : Definable A L s
f : α ≃ β
i : β → M
⊢ (fun g => g ∘ ↑f.symm) ((fun g => g ∘ ↑f) i) = i

tactic: simp only [Function.comp_apply, Equiv.apply_symm_apply]
state_before: case h₁.h
M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type u_1
B : Set M
s✝ : Set (α → M)
s : Set (β → M)
h : Definable A L s
f : α ≃ β
i : β → M
b : β
⊢ (fun g => g ∘ ↑f.symm) ((fun g => g ∘ ↑f) i) b = i b

tactic: intro i
state_before: case h₂
M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type u_1
B : Set M
s✝ : Set (α → M)
s : Set (β → M)
h : Definable A L s
f : α ≃ β
⊢ Function.RightInverse (fun g => g ∘ ↑f.symm) fun g => g ∘ ↑f

tactic: ext a
state_before: case h₂
M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type u_1
B : Set M
s✝ : Set (α → M)
s : Set (β → M)
h : Definable A L s
f : α ≃ β
i : α → M
⊢ (fun g => g ∘ ↑f) ((fun g => g ∘ ↑f.symm) i) = i

tactic: simp
state_before: case h₂.h
M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type u_1
B : Set M
s✝ : Set (α → M)
s : Set (β → M)
h : Definable A L s
f : α ≃ β
i : α → M
a : α
⊢ (fun g => g ∘ ↑f) ((fun g => g ∘ ↑f.symm) i) a = i a
Theorem: Nat.Primrec.sub
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: p : ℕ
⊢ unpaired (fun z n => Nat.rec (id z) (fun y IH => Nat.pred (unpair (unpair (Nat.pair z (Nat.pair y IH))).snd).snd) n)
      p =
    unpaired (fun x x_1 => x - x_1) p

tactic: induction p.unpair.2 <;> simp [*, sub_succ]
state_before: p : ℕ
⊢ Nat.rec (unpair p).fst (fun y IH => Nat.pred IH) (unpair p).snd = (unpair p).fst - (unpair p).snd
Theorem: Finset.mulDysonEtransform.smul_finset_snd_subset_fst
File: Mathlib/Combinatorics/Additive/Etransform.lean

tactic: dsimp
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ e • (mulDysonEtransform e x).snd ⊆ (mulDysonEtransform e x).fst

tactic: rw [smul_finset_inter, smul_inv_smul, inter_comm]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ e • (x.snd ∩ e⁻¹ • x.fst) ⊆ x.fst ∪ e • x.snd

tactic: exact inter_subset_union
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ x.fst ∩ e • x.snd ⊆ x.fst ∪ e • x.snd
Theorem: PartENat.withTopEquiv_symm_lt
File: Mathlib/Data/Nat/PartENat.lean

tactic: rw [← withTopEquiv_lt]
state_before: x y : ℕ∞
⊢ ↑withTopEquiv.symm x < ↑withTopEquiv.symm y ↔ x < y

tactic: simp
state_before: x y : ℕ∞
⊢ ↑withTopEquiv (↑withTopEquiv.symm x) < ↑withTopEquiv (↑withTopEquiv.symm y) ↔ x < y
Theorem: CategoryTheory.Splitting.inl_comp_iso_eq
File: Mathlib/Algebra/Homology/ShortExact/Preadditive.lean

tactic: rw [Iso.comp_inv_eq, h.comp_iso_eq_inl]
state_before: 𝒜 : Type u_2
inst✝² : Category 𝒜
A B C A' B' C' : 𝒜
f : A ⟶ B
g : B ⟶ C
f' : A' ⟶ B'
g' : B' ⟶ C'
inst✝¹ : HasZeroMorphisms 𝒜
inst✝ : HasBinaryBiproducts 𝒜
h : Splitting f g
⊢ biprod.inl ≫ h.iso.inv = f
Theorem: sdiff_bot
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [sdiff_le_iff, bot_sup_eq]
state_before: ι : Type ?u.94184
α : Type u_1
β : Type ?u.94190
inst✝ : GeneralizedCoheytingAlgebra α
a b✝ c d b : α
⊢ a \ ⊥ ≤ b ↔ a ≤ b
Theorem: Filter.Tendsto.prod_map_prod_atBot
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [← prod_atBot_atBot_eq]
state_before: ι : Type ?u.283686
ι' : Type ?u.283689
α : Type u_2
β : Type u_3
γ : Type u_1
inst✝ : SemilatticeInf γ
F : Filter α
G : Filter β
f : α → γ
g : β → γ
hf : Tendsto f F atBot
hg : Tendsto g G atBot
⊢ Tendsto (Prod.map f g) (F ×ˢ G) atBot

tactic: exact hf.prod_map hg
state_before: ι : Type ?u.283686
ι' : Type ?u.283689
α : Type u_2
β : Type u_3
γ : Type u_1
inst✝ : SemilatticeInf γ
F : Filter α
G : Filter β
f : α → γ
g : β → γ
hf : Tendsto f F atBot
hg : Tendsto g G atBot
⊢ Tendsto (Prod.map f g) (F ×ˢ G) (atBot ×ˢ atBot)
Theorem: Asymptotics.isEquivalent_iff_exists_eq_mul
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

tactic: rw [IsEquivalent, isLittleO_iff_exists_eq_mul]
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
⊢ u ~[l] v ↔ ∃ φ x, u =ᶠ[l] φ * v

tactic: constructor <;> rintro ⟨φ, hφ, h⟩ <;> [refine' ⟨φ + 1, _, _⟩; refine' ⟨φ - 1, _, _⟩]
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
⊢ (∃ φ _hφ, u - v =ᶠ[l] φ * v) ↔ ∃ φ x, u =ᶠ[l] φ * v

tactic: conv in 𝓝 _ => rw [← zero_add (1 : β)]
state_before: case mp.intro.intro.refine'_1
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
φ : α → β
hφ : Tendsto φ l (𝓝 0)
h : u - v =ᶠ[l] φ * v
⊢ Tendsto (φ + 1) l (𝓝 1)

tactic: exact hφ.add tendsto_const_nhds
state_before: case mp.intro.intro.refine'_1
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
φ : α → β
hφ : Tendsto φ l (𝓝 0)
h : u - v =ᶠ[l] φ * v
⊢ Tendsto (φ + 1) l (𝓝 (0 + 1))

tactic: convert h.add (EventuallyEq.refl l v) <;> simp [add_mul]
state_before: case mp.intro.intro.refine'_2
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
φ : α → β
hφ : Tendsto φ l (𝓝 0)
h : u - v =ᶠ[l] φ * v
⊢ u =ᶠ[l] (φ + 1) * v

tactic: conv in 𝓝 _ => rw [← sub_self (1 : β)]
state_before: case mpr.intro.intro.refine'_1
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
φ : α → β
hφ : Tendsto φ l (𝓝 1)
h : u =ᶠ[l] φ * v
⊢ Tendsto (φ - 1) l (𝓝 0)

tactic: exact hφ.sub tendsto_const_nhds
state_before: case mpr.intro.intro.refine'_1
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
φ : α → β
hφ : Tendsto φ l (𝓝 1)
h : u =ᶠ[l] φ * v
⊢ Tendsto (φ - 1) l (𝓝 (1 - 1))

tactic: convert h.sub (EventuallyEq.refl l v)
state_before: case mpr.intro.intro.refine'_2
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
φ : α → β
hφ : Tendsto φ l (𝓝 1)
h : u =ᶠ[l] φ * v
⊢ u - v =ᶠ[l] (φ - 1) * v

tactic: simp [sub_mul]
state_before: case h.e'_5.h
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
φ : α → β
hφ : Tendsto φ l (𝓝 1)
h : u =ᶠ[l] φ * v
x✝ : α
⊢ ((φ - 1) * v) x✝ = (φ * v) x✝ - v x✝
Theorem: TopologicalSpace.IsTopologicalBasis.exists_closure_subset
File: Mathlib/Topology/Separation.lean

tactic: simpa only [exists_prop, and_assoc] using hB.nhds_hasBasis.nhds_closure.mem_iff.mp h
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : RegularSpace α
a✝ : α
s✝ : Set α
B : Set (Set α)
hB : IsTopologicalBasis B
a : α
s : Set α
h : s ∈ 𝓝 a
⊢ ∃ t, t ∈ B ∧ a ∈ t ∧ closure t ⊆ s
Theorem: MvPolynomial.degreeOf_eq_sup
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: classical
rw [degreeOf_def, degrees, Multiset.count_finset_sup]
congr
ext
simp
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.279512
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
n : σ
f : MvPolynomial σ R
⊢ degreeOf n f = Finset.sup (support f) fun m => ↑m n

tactic: rw [degreeOf_def, degrees, Multiset.count_finset_sup]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.279512
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
n : σ
f : MvPolynomial σ R
⊢ degreeOf n f = Finset.sup (support f) fun m => ↑m n

tactic: congr
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.279512
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
n : σ
f : MvPolynomial σ R
⊢ (Finset.sup (support f) fun a => Multiset.count n (↑toMultiset a)) = Finset.sup (support f) fun m => ↑m n

tactic: ext
state_before: case e_f
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.279512
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
n : σ
f : MvPolynomial σ R
⊢ (fun a => Multiset.count n (↑toMultiset a)) = fun m => ↑m n

tactic: simp
state_before: case e_f.h
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.279512
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
n : σ
f : MvPolynomial σ R
x✝ : σ →₀ ℕ
⊢ Multiset.count n (↑toMultiset x✝) = ↑x✝ n
Theorem: SimpleGraph.map_le_iff_le_comap
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: rintro h _ _ ⟨u, v, ha, rfl, rfl⟩
state_before: ι : Sort ?u.241583
𝕜 : Type ?u.241586
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
f : V ↪ W
G : SimpleGraph V
G' : SimpleGraph W
⊢ G ≤ SimpleGraph.comap (↑f) G' → SimpleGraph.map f G ≤ G'

tactic: exact h ha
state_before: case intro.intro.intro.intro
ι : Sort ?u.241583
𝕜 : Type ?u.241586
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
f : V ↪ W
G : SimpleGraph V
G' : SimpleGraph W
h : G ≤ SimpleGraph.comap (↑f) G'
u v : V
ha : Adj G u v
⊢ Adj G' (↑f u) (↑f v)
Theorem: exists_seq_strictAnti_tendsto'
File: Mathlib/Topology/Order/Basic.lean

tactic: simpa only [dual_Ioo]
  using exists_seq_strictMono_tendsto' (α := αᵒᵈ) (OrderDual.toDual_lt_toDual.2 hy)
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁷ : TopologicalSpace α
inst✝⁶ : TopologicalSpace β
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : OrderTopology α
inst✝² : OrderTopology β
inst✝¹ : DenselyOrdered α
inst✝ : FirstCountableTopology α
x y : α
hy : x < y
⊢ ∃ u, StrictAnti u ∧ (∀ (n : ℕ), u n ∈ Ioo x y) ∧ Tendsto u atTop (𝓝 x)
Theorem: Fin.range_cons
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: rw [range_fin_succ, cons_zero, tail_cons]
state_before: m n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x✝ : α✝ 0
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ (succ i)
i : Fin n✝
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
n : ℕ
x : α
b : Fin n → α
⊢ Set.range (cons x b) = insert x (Set.range b)
Theorem: LocalHomeomorph.eventually_nhds
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: rw [e.map_nhds_eq hx]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.33371
δ : Type ?u.33374
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e' : LocalHomeomorph β γ
e : LocalHomeomorph α β
x : α
p : β → Prop
hx : x ∈ e.source
⊢ (∀ᶠ (y : β) in 𝓝 (↑e x), p y) ↔ ∀ᶠ (b : β) in map (fun x => ↑e x) (𝓝 x), p b
Theorem: Nat.floor_div_eq_div
File: Mathlib/Algebra/Order/Floor.lean

tactic: convert floor_div_nat (m : α) n
state_before: F : Type ?u.97534
α : Type u_1
β : Type ?u.97540
inst✝¹ : LinearOrderedSemifield α
inst✝ : FloorSemiring α
m n : ℕ
⊢ ⌊↑m / ↑n⌋₊ = m / n

tactic: rw [m.floor_coe]
state_before: case h.e'_3.h.e'_5
F : Type ?u.97534
α : Type u_1
β : Type ?u.97540
inst✝¹ : LinearOrderedSemifield α
inst✝ : FloorSemiring α
m n : ℕ
⊢ m = ⌊↑m⌋₊
Theorem: Multiset.cons_union_distrib
File: Mathlib/Data/Multiset/Basic.lean

tactic: simpa using add_union_distrib (a ::ₘ 0) s t
state_before: α : Type u_1
β : Type ?u.187851
γ : Type ?u.187854
inst✝ : DecidableEq α
s✝ t✝ u : Multiset α
a✝ b a : α
s t : Multiset α
⊢ a ::ₘ (s ∪ t) = a ::ₘ s ∪ a ::ₘ t
Theorem: Array.mapIdx_induction
File: Std/Data/Array/Lemmas.lean

tactic: have := SatisfiesM_mapIdxM (m := Id) (as := as) (f := f) motive h0
state_before: α : Type u_1
β : Type u_2
as : Array α
f : Fin (size as) → α → β
motive : Nat → Prop
h0 : motive 0
p : Fin (size as) → β → Prop
hs : ∀ (i : Fin (size as)), motive i.val → p i (f i as[i]) ∧ motive (i.val + 1)
⊢ motive (size as) ∧ ∃ eq, ∀ (i : Nat) (h : i < size as), p { val := i, isLt := h } (mapIdx as f)[i]

tactic: simp [SatisfiesM_Id_eq] at this
state_before: α : Type u_1
β : Type u_2
as : Array α
f : Fin (size as) → α → β
motive : Nat → Prop
h0 : motive 0
p : Fin (size as) → β → Prop
hs : ∀ (i : Fin (size as)), motive i.val → p i (f i as[i]) ∧ motive (i.val + 1)
this :
  ∀ (p : Fin (size as) → β → Prop),
    (∀ (i : Fin (size as)), motive i.val → SatisfiesM (fun x => p i x ∧ motive (i.val + 1)) (f i as[i])) →
      SatisfiesM (fun arr => motive (size as) ∧ ∃ eq, ∀ (i : Nat) (h : i < size as), p { val := i, isLt := h } arr[i])
        (mapIdxM as f)
⊢ motive (size as) ∧ ∃ eq, ∀ (i : Nat) (h : i < size as), p { val := i, isLt := h } (mapIdx as f)[i]

tactic: exact this _ hs
state_before: α : Type u_1
β : Type u_2
as : Array α
f : Fin (size as) → α → β
motive : Nat → Prop
h0 : motive 0
p : Fin (size as) → β → Prop
hs : ∀ (i : Fin (size as)), motive i.val → p i (f i as[i]) ∧ motive (i.val + 1)
this :
  ∀ (p : Fin (size as) → β → Prop),
    (∀ (i : Fin (size as)), motive i.val → p i (f i as[i.val]) ∧ motive (i.val + 1)) →
      motive (size as) ∧ ∃ eq, ∀ (i : Nat) (h : i < size as), p { val := i, isLt := h } (mapIdxM as f)[i]
⊢ motive (size as) ∧ ∃ eq, ∀ (i : Nat) (h : i < size as), p { val := i, isLt := h } (mapIdx as f)[i]
Theorem: LipschitzWith.of_edist_le
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simp only [ENNReal.coe_one, one_mul, h]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
x✝ y✝ : α
r : ℝ≥0∞
h : ∀ (x y : α), edist (f x) (f y) ≤ edist x y
x y : α
⊢ edist (f x) (f y) ≤ ↑1 * edist x y
Theorem: Matrix.reindexLinearEquiv_comp
File: Mathlib/LinearAlgebra/Matrix/Reindex.lean

tactic: rw [← reindexLinearEquiv_trans]
state_before: l : Type ?u.22310
m : Type u_1
n : Type u_3
o : Type ?u.22319
l' : Type ?u.22322
m' : Type u_2
n' : Type u_4
o' : Type ?u.22331
m'' : Type u_5
n'' : Type u_6
R : Type u_8
A : Type u_7
inst✝² : Semiring R
inst✝¹ : AddCommMonoid A
inst✝ : Module R A
e₁ : m ≃ m'
e₂ : n ≃ n'
e₁' : m' ≃ m''
e₂' : n' ≃ n''
⊢ ↑(reindexLinearEquiv R A e₁' e₂') ∘ ↑(reindexLinearEquiv R A e₁ e₂) =
    ↑(reindexLinearEquiv R A (e₁.trans e₁') (e₂.trans e₂'))

tactic: rfl
state_before: l : Type ?u.22310
m : Type u_1
n : Type u_3
o : Type ?u.22319
l' : Type ?u.22322
m' : Type u_2
n' : Type u_4
o' : Type ?u.22331
m'' : Type u_5
n'' : Type u_6
R : Type u_8
A : Type u_7
inst✝² : Semiring R
inst✝¹ : AddCommMonoid A
inst✝ : Module R A
e₁ : m ≃ m'
e₂ : n ≃ n'
e₁' : m' ≃ m''
e₂' : n' ≃ n''
⊢ ↑(reindexLinearEquiv R A e₁' e₂') ∘ ↑(reindexLinearEquiv R A e₁ e₂) =
    ↑(LinearEquiv.trans (reindexLinearEquiv R A e₁ e₂) (reindexLinearEquiv R A e₁' e₂'))
Theorem: AntivaryOn.sum_smul_lt_sum_comp_perm_smul_iff
File: Mathlib/Algebra/Order/Rearrangement.lean

tactic: simp [← hfg.sum_smul_eq_sum_comp_perm_smul_iff hσ, eq_comm, lt_iff_le_and_ne,
  hfg.sum_smul_le_sum_comp_perm_smul hσ]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : OrderedSMul α β
s : Finset ι
σ : Perm ι
f : ι → α
g : ι → β
hfg : AntivaryOn f g ↑s
hσ : {x | ↑σ x ≠ x} ⊆ ↑s
⊢ ∑ i in s, f i • g i < ∑ i in s, f (↑σ i) • g i ↔ ¬AntivaryOn (f ∘ ↑σ) g ↑s
Theorem: HahnSeries.sub_coeff
File: Mathlib/RingTheory/HahnSeries.lean

tactic: simp
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddGroup R
x y : HahnSeries Γ R
a : Γ
⊢ coeff (x - y) a = coeff x a - coeff y a
Theorem: Dfinsupp.disjoint_iff
File: Mathlib/Data/Dfinsupp/Order.lean

tactic: rw [disjoint_iff, disjoint_iff, Dfinsupp.bot_eq_zero, ← Dfinsupp.support_eq_empty,
  Dfinsupp.support_inf]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → CanonicallyLinearOrderedAddMonoid (α i)
inst✝ : DecidableEq ι
f g : Π₀ (i : ι), α i
⊢ Disjoint f g ↔ Disjoint (support f) (support g)

tactic: rfl
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → CanonicallyLinearOrderedAddMonoid (α i)
inst✝ : DecidableEq ι
f g : Π₀ (i : ι), α i
⊢ support f ∩ support g = ∅ ↔ support f ⊓ support g = ⊥
Theorem: Function.Periodic.const_inv_smul
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [inv_inv] using h.const_smul a⁻¹
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
f g : α → β
c c₁ c₂ x : α
inst✝² : AddMonoid α
inst✝¹ : Group γ
inst✝ : DistribMulAction γ α
h : Periodic f c
a : γ
⊢ Periodic (fun x => f (a⁻¹ • x)) (a • c)
Theorem: add_eq_right_iff_le
File: Mathlib/Algebra/Order/Kleene.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.20923
ι : Type ?u.20926
π : ι → Type ?u.20931
inst✝ : IdemSemiring α
a b c : α
⊢ a + b = b ↔ a ≤ b
Theorem: toIocMod_sub
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [one_zsmul] using toIocMod_sub_zsmul hp a b 1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp a (b - p) = toIocMod hp a b
Theorem: Real.pi_div_four_le_arcsin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [← sin_pi_div_four, le_arcsin_iff_sin_le']
state_before: x : ℝ
⊢ π / 4 ≤ arcsin x ↔ sqrt 2 / 2 ≤ x

tactic: have := pi_pos
state_before: x : ℝ
⊢ π / 4 ∈ Ioc (-(π / 2)) (π / 2)

tactic: constructor <;> linarith
state_before: x : ℝ
this : 0 < π
⊢ π / 4 ∈ Ioc (-(π / 2)) (π / 2)
Theorem: Int.dvd_lcm_right
File: Mathlib/Data/Int/GCD.lean

tactic: rw [Int.lcm]
state_before: i j : ℤ
⊢ j ∣ ↑(lcm i j)

tactic: apply coe_nat_dvd_right.mpr
state_before: i j : ℤ
⊢ j ∣ ↑(Nat.lcm (natAbs i) (natAbs j))

tactic: apply Nat.dvd_lcm_right
state_before: i j : ℤ
⊢ natAbs j ∣ Nat.lcm (natAbs i) (natAbs j)
Theorem: CategoryTheory.Limits.IsImage.e_isoExt_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp
state_before: C : Type u
inst✝ : Category C
X Y : C
f : X ⟶ Y
F F' : MonoFactorisation f
hF : IsImage F
hF' : IsImage F'
⊢ F.e ≫ (isoExt hF hF').hom = F'.e
Theorem: MvPFunctor.M.dest'_eq_dest'
File: Mathlib/Data/PFunctor/Multivariate/M.lean

tactic: cases h₁.symm.trans h₂
state_before: n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
x : PFunctor.M (last P)
a₁ : P.A
f₁ : PFunctor.B (last P) a₁ → PFunctor.M (last P)
h₁ : PFunctor.M.dest x = { fst := a₁, snd := f₁ }
a₂ : P.A
f₂ : PFunctor.B (last P) a₂ → PFunctor.M (last P)
h₂ : PFunctor.M.dest x = { fst := a₂, snd := f₂ }
f' : Path P x ⟹ α
⊢ dest' P h₁ f' = dest' P h₂ f'

tactic: rfl
state_before: case refl
n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
x : PFunctor.M (last P)
a₁ : P.A
f₁ : PFunctor.B (last P) a₁ → PFunctor.M (last P)
h₁ : PFunctor.M.dest x = { fst := a₁, snd := f₁ }
f' : Path P x ⟹ α
h₂ : PFunctor.M.dest x = { fst := a₁, snd := f₁ }
⊢ dest' P h₁ f' = dest' P h₂ f'
Theorem: one_lt_gold
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: refine' lt_of_mul_lt_mul_left _ (le_of_lt gold_pos)
state_before: ⊢ 1 < φ

tactic: simp [← sq, gold_pos, zero_lt_one, - div_pow]
state_before: ⊢ φ * 1 < φ * φ
Theorem: Finset.erase_singleton
File: Mathlib/Data/Finset/Basic.lean

tactic: ext x
state_before: α : Type u_1
β : Type ?u.206883
γ : Type ?u.206886
inst✝ : DecidableEq α
s t u v : Finset α
a✝ b a : α
⊢ erase {a} a = ∅

tactic: simp
state_before: case a
α : Type u_1
β : Type ?u.206883
γ : Type ?u.206886
inst✝ : DecidableEq α
s t u v : Finset α
a✝ b a x : α
⊢ x ∈ erase {a} a ↔ x ∈ ∅
Theorem: CategoryTheory.Abelian.has_projective_separator
File: Mathlib/CategoryTheory/Abelian/Generator.lean

tactic: obtain ⟨T, hT₁, hT₂⟩ := has_injective_coseparator (op G) ((isSeparator_op_iff _).2 hG)
state_before: C : Type u
inst✝³ : Category C
inst✝² : Abelian C
inst✝¹ : HasColimits C
inst✝ : EnoughProjectives C
G : C
hG : IsCoseparator G
⊢ ∃ G, Projective G ∧ IsSeparator G

tactic: exact ⟨unop T, inferInstance, (isSeparator_unop_iff _).2 hT₂⟩
state_before: case intro.intro
C : Type u
inst✝³ : Category C
inst✝² : Abelian C
inst✝¹ : HasColimits C
inst✝ : EnoughProjectives C
G : C
hG : IsCoseparator G
T : Cᵒᵖ
hT₁ : Injective T
hT₂ : IsCoseparator T
⊢ ∃ G, Projective G ∧ IsSeparator G
Theorem: mapClusterPt_of_comp
File: Mathlib/Topology/Basic.lean

tactic: have :=
  calc
    map (u ∘ φ) p = map u (map φ p) := map_map
    _ ≤ map u F := map_mono h
state_before: α : Type u
β : Type v
ι✝ : Sort w
a : α
s s₁ s₂ t : Set α
p✝ p₁ p₂ : α → Prop
inst✝¹ : TopologicalSpace α
ι : Type u_1
δ : Type u_2
F : Filter ι
φ : δ → ι
p : Filter δ
x : α
u : ι → α
inst✝ : NeBot p
h : Tendsto φ p F
H : Tendsto (u ∘ φ) p (𝓝 x)
⊢ MapClusterPt x F u

tactic: have : map (u ∘ φ) p ≤ 𝓝 x ⊓ map u F := le_inf H this
state_before: α : Type u
β : Type v
ι✝ : Sort w
a : α
s s₁ s₂ t : Set α
p✝ p₁ p₂ : α → Prop
inst✝¹ : TopologicalSpace α
ι : Type u_1
δ : Type u_2
F : Filter ι
φ : δ → ι
p : Filter δ
x : α
u : ι → α
inst✝ : NeBot p
h : Tendsto φ p F
H : Tendsto (u ∘ φ) p (𝓝 x)
this : map (u ∘ φ) p ≤ map u F
⊢ MapClusterPt x F u

tactic: exact neBot_of_le this
state_before: α : Type u
β : Type v
ι✝ : Sort w
a : α
s s₁ s₂ t : Set α
p✝ p₁ p₂ : α → Prop
inst✝¹ : TopologicalSpace α
ι : Type u_1
δ : Type u_2
F : Filter ι
φ : δ → ι
p : Filter δ
x : α
u : ι → α
inst✝ : NeBot p
h : Tendsto φ p F
H : Tendsto (u ∘ φ) p (𝓝 x)
this✝ : map (u ∘ φ) p ≤ map u F
this : map (u ∘ φ) p ≤ 𝓝 x ⊓ map u F
⊢ MapClusterPt x F u