1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Pell.isPell_pellZd
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: let o := isPell_one a1
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ IsPell (pellZd a1 (n + 1))
state_after: a : ℕ
a1 : 1 < a
n : ℕ
o : IsPell { re := ↑a, im := 1 } := isPell_one a1
⊢ IsPell (pellZd a1 (n + 1))

tactic: simp
state_before: a : ℕ
a1 : 1 < a
n : ℕ
o : IsPell { re := ↑a, im := 1 } := isPell_one a1
⊢ IsPell (pellZd a1 (n + 1))
state_after: a : ℕ
a1 : 1 < a
n : ℕ
o : IsPell { re := ↑a, im := 1 } := isPell_one a1
⊢ IsPell (pellZd a1 n * { re := ↑a, im := 1 })

tactic: exact Pell.isPell_mul (isPell_pellZd n) o
state_before: a : ℕ
a1 : 1 < a
n : ℕ
o : IsPell { re := ↑a, im := 1 } := isPell_one a1
⊢ IsPell (pellZd a1 n * { re := ↑a, im := 1 })
state_after: no goals
Theorem: QPF.suppPreservation_iff_uniform
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: constructor
state_before: F : Type u → Type u
q : QPF F
⊢ SuppPreservation ↔ IsUniform
state_after: case mp
F : Type u → Type u
q : QPF F
⊢ SuppPreservation → IsUniform

case mpr
F : Type u → Type u
q : QPF F
⊢ IsUniform → SuppPreservation

tactic: intro h α a a' f f' h'
state_before: case mp
F : Type u → Type u
q : QPF F
⊢ SuppPreservation → IsUniform
state_after: case mp
F : Type u → Type u
q : QPF F
h : SuppPreservation
α : Type u
a a' : (P F).A
f : (P F).B a → α
f' : (P F).B a' → α
h' : abs ⟨a, f⟩ = abs ⟨a', f'⟩
⊢ f '' univ = f' '' univ

tactic: rw [← PFunctor.supp_eq, ← PFunctor.supp_eq, ← h, h', h]
state_before: case mp
F : Type u → Type u
q : QPF F
h : SuppPreservation
α : Type u
a a' : (P F).A
f : (P F).B a → α
f' : (P F).B a' → α
h' : abs ⟨a, f⟩ = abs ⟨a', f'⟩
⊢ f '' univ = f' '' univ
state_after: no goals

tactic: rintro h α ⟨a, f⟩
state_before: case mpr
F : Type u → Type u
q : QPF F
⊢ IsUniform → SuppPreservation
state_after: case mpr.mk
F : Type u → Type u
q : QPF F
h : IsUniform
α : Type u
a : (P F).A
f : (P F).B a → α
⊢ supp (abs ⟨a, f⟩) = supp ⟨a, f⟩

tactic: rwa [supp_eq_of_isUniform, PFunctor.supp_eq]
state_before: case mpr.mk
F : Type u → Type u
q : QPF F
h : IsUniform
α : Type u
a : (P F).A
f : (P F).B a → α
⊢ supp (abs ⟨a, f⟩) = supp ⟨a, f⟩
state_after: no goals
Theorem: CategoryTheory.Adjunction.homEquiv_naturality_right_square_iff
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

tactic: simpa only [Equiv.apply_symm_apply]
using homEquiv_naturality_left_square adj _ _ _ _ w
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
f : X' ⟶ X
g : X ⟶ G.obj Y'
h : X' ⟶ G.obj Y
k : Y ⟶ Y'
w : F.map f ≫ (adj.homEquiv X Y').symm g = (adj.homEquiv X' Y).symm h ≫ k
⊢ f ≫ g = h ≫ G.map k
state_after: no goals
Theorem: BoxIntegral.Integrable.cauchy_map_integralSum_toFilteriUnion
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: refine ⟨inferInstance, ?_⟩
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁ π₂ : TaggedPrepartition I
h : Integrable I l f vol
π₀ : Prepartition I
⊢ Cauchy (Filter.map (integralSum f vol) (l.toFilteriUnion I π₀))
state_after: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁ π₂ : TaggedPrepartition I
h : Integrable I l f vol
π₀ : Prepartition I
⊢ Filter.map (integralSum f vol) (l.toFilteriUnion I π₀) ×ˢ Filter.map (integralSum f vol) (l.toFilteriUnion I π₀) ≤ 𝓤 F

tactic: rw [prod_map_map_eq, ← toFilter_inf_iUnion_eq, ← prod_inf_prod, prod_principal_principal]
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁ π₂ : TaggedPrepartition I
h : Integrable I l f vol
π₀ : Prepartition I
⊢ Filter.map (integralSum f vol) (l.toFilteriUnion I π₀) ×ˢ Filter.map (integralSum f vol) (l.toFilteriUnion I π₀) ≤ 𝓤 F
state_after: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁ π₂ : TaggedPrepartition I
h : Integrable I l f vol
π₀ : Prepartition I
⊢ Filter.map (fun p => (integralSum f vol p.1, integralSum f vol p.2))
      (l.toFilter I ×ˢ l.toFilter I ⊓ 𝓟 ({π | π.iUnion = π₀.iUnion} ×ˢ {π | π.iUnion = π₀.iUnion})) ≤
    𝓤 F

tactic: exact h.tendsto_integralSum_toFilter_prod_self_inf_iUnion_eq_uniformity.mono_left
  (inf_le_inf_left _ <| principal_mono.2 fun π h => h.1.trans h.2.symm)
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁ π₂ : TaggedPrepartition I
h : Integrable I l f vol
π₀ : Prepartition I
⊢ Filter.map (fun p => (integralSum f vol p.1, integralSum f vol p.2))
      (l.toFilter I ×ˢ l.toFilter I ⊓ 𝓟 ({π | π.iUnion = π₀.iUnion} ×ˢ {π | π.iUnion = π₀.iUnion})) ≤
    𝓤 F
state_after: no goals
Theorem: List.count_eq_length
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

tactic: rw [count, countP_eq_length]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l : List α
⊢ count a l = l.length ↔ ∀ (b : α), b ∈ l → a = b
state_after: α : Type u_1
inst✝ : DecidableEq α
a : α
l : List α
⊢ (∀ (a_1 : α), a_1 ∈ l → (a_1 == a) = true) ↔ ∀ (b : α), b ∈ l → a = b

tactic: refine ⟨fun h b hb => Eq.symm ?_, fun h b hb => ?_⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l : List α
⊢ (∀ (a_1 : α), a_1 ∈ l → (a_1 == a) = true) ↔ ∀ (b : α), b ∈ l → a = b
state_after: case refine_1
α : Type u_1
inst✝ : DecidableEq α
a : α
l : List α
h : ∀ (a_1 : α), a_1 ∈ l → (a_1 == a) = true
b : α
hb : b ∈ l
⊢ b = a

case refine_2
α : Type u_1
inst✝ : DecidableEq α
a : α
l : List α
h : ∀ (b : α), b ∈ l → a = b
b : α
hb : b ∈ l
⊢ (b == a) = true

tactic: simpa using h b hb
state_before: case refine_1
α : Type u_1
inst✝ : DecidableEq α
a : α
l : List α
h : ∀ (a_1 : α), a_1 ∈ l → (a_1 == a) = true
b : α
hb : b ∈ l
⊢ b = a
state_after: no goals

tactic: rw [h b hb, beq_self_eq_true]
state_before: case refine_2
α : Type u_1
inst✝ : DecidableEq α
a : α
l : List α
h : ∀ (b : α), b ∈ l → a = b
b : α
hb : b ∈ l
⊢ (b == a) = true
state_after: no goals
Theorem: HasFTaylorSeriesUpToOn.add
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

tactic: convert HasFTaylorSeriesUpToOn.continuousLinearMap_comp
  (ContinuousLinearMap.fst 𝕜 F F + .snd 𝕜 F F) (hf.prod hg)
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
q : E → FormalMultilinearSeries 𝕜 E F
g : E → F
hf : HasFTaylorSeriesUpToOn n f p s
hg : HasFTaylorSeriesUpToOn n g q s
⊢ HasFTaylorSeriesUpToOn n (f + g) (p + q) s
state_after: no goals
Theorem: ProbabilityTheory.gammaPDFReal_pos
File: Mathlib/Probability/Distributions/Gamma.lean

tactic: simp only [gammaPDFReal, if_pos hx.le]
state_before: x a r : ℝ
ha : 0 < a
hr : 0 < r
hx : 0 < x
⊢ 0 < gammaPDFReal a r x
state_after: x a r : ℝ
ha : 0 < a
hr : 0 < r
hx : 0 < x
⊢ 0 < r ^ a / Gamma a * x ^ (a - 1) * rexp (-(r * x))

tactic: positivity
state_before: x a r : ℝ
ha : 0 < a
hr : 0 < r
hx : 0 < x
⊢ 0 < r ^ a / Gamma a * x ^ (a - 1) * rexp (-(r * x))
state_after: no goals
Theorem: MeasureTheory.measure_biUnion_null_iff
File: Mathlib/MeasureTheory/OuterMeasure/Basic.lean

tactic: refine ⟨fun h i hi ↦ measure_mono_null (subset_biUnion_of_mem hi) h, fun h ↦ ?_⟩
state_before: α : Type u_1
ι : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s✝ t : Set α
I : Set ι
hI : I.Countable
s : ι → Set α
⊢ μ (⋃ i ∈ I, s i) = 0 ↔ ∀ i ∈ I, μ (s i) = 0
state_after: α : Type u_1
ι : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s✝ t : Set α
I : Set ι
hI : I.Countable
s : ι → Set α
h : ∀ i ∈ I, μ (s i) = 0
⊢ μ (⋃ i ∈ I, s i) = 0

tactic: have _ := hI.to_subtype
state_before: α : Type u_1
ι : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s✝ t : Set α
I : Set ι
hI : I.Countable
s : ι → Set α
h : ∀ i ∈ I, μ (s i) = 0
⊢ μ (⋃ i ∈ I, s i) = 0
state_after: α : Type u_1
ι : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s✝ t : Set α
I : Set ι
hI : I.Countable
s : ι → Set α
h : ∀ i ∈ I, μ (s i) = 0
x✝ : Countable ↑I
⊢ μ (⋃ i ∈ I, s i) = 0

tactic: simpa [h] using measure_iUnion_le (μ := μ) fun x : I ↦ s x
state_before: α : Type u_1
ι : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s✝ t : Set α
I : Set ι
hI : I.Countable
s : ι → Set α
h : ∀ i ∈ I, μ (s i) = 0
x✝ : Countable ↑I
⊢ μ (⋃ i ∈ I, s i) = 0
state_after: no goals
Theorem: Algebra.pushoutDesc_right
File: Mathlib/RingTheory/IsTensorProduct.lean

tactic: rw [f.map_smul, smul_mul_assoc]
state_before: R : Type u_1
M : Type v₁
N : Type v₂
S : Type v₃
inst✝³³ : AddCommMonoid M
inst✝³² : AddCommMonoid N
inst✝³¹ : CommSemiring R
inst✝³⁰ : CommSemiring S
inst✝²⁹ : Algebra R S
inst✝²⁸ : Module R M
inst✝²⁷ : Module R N
inst✝²⁶ : Module S N
inst✝²⁵ : IsScalarTower R S N
f✝ : M →ₗ[R] N
h : IsBaseChange S f✝
P : Type u_2
Q : Type u_3
inst✝²⁴ : AddCommMonoid P
inst✝²³ : Module R P
inst✝²² : AddCommMonoid Q
inst✝²¹ : Module S Q
T : Type u_4
O : Type u_5
inst✝²⁰ : CommSemiring T
inst✝¹⁹ : Algebra R T
inst✝¹⁸ : Algebra S T
inst✝¹⁷ : IsScalarTower R S T
inst✝¹⁶ : AddCommMonoid O
inst✝¹⁵ : Module R O
inst✝¹⁴ : Module S O
inst✝¹³ : Module T O
inst✝¹² : IsScalarTower S T O
inst✝¹¹ : IsScalarTower R S O
inst✝¹⁰ : IsScalarTower R T O
R' : Type u_6
S' : Type u_7
inst✝⁹ : CommSemiring R'
inst✝⁸ : CommSemiring S'
inst✝⁷ : Algebra R R'
inst✝⁶ : Algebra S S'
inst✝⁵ : Algebra R' S'
inst✝⁴ : Algebra R S'
inst✝³ : IsScalarTower R R' S'
inst✝² : IsScalarTower R S S'
H✝ : IsPushout R S R' S'
A : Type u_8
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : S →ₐ[R] A
g : R' →ₐ[R] A
H : ∀ (x : S) (y : R'), f x * g y = g y * f x
x : R'
this : Module S A := Module.compHom A f.toRingHom
r : R
s : S
a : A
⊢ f (r • s) * a = r • (f s * a)
state_after: no goals
Theorem: DFinsupp.erase_eq_sub_single
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: ext j
state_before: ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddGroup (β i)
f : Π₀ (i : ι), β i
i : ι
⊢ erase i f = f - single i (f i)
state_after: case h
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddGroup (β i)
f : Π₀ (i : ι), β i
i j : ι
⊢ (erase i f) j = (f - single i (f i)) j

tactic: rcases eq_or_ne i j with (rfl | h)
state_before: case h
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddGroup (β i)
f : Π₀ (i : ι), β i
i j : ι
⊢ (erase i f) j = (f - single i (f i)) j
state_after: case h.inl
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddGroup (β i)
f : Π₀ (i : ι), β i
i : ι
⊢ (erase i f) i = (f - single i (f i)) i

case h.inr
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddGroup (β i)
f : Π₀ (i : ι), β i
i j : ι
h : i ≠ j
⊢ (erase i f) j = (f - single i (f i)) j

tactic: simp
state_before: case h.inl
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddGroup (β i)
f : Π₀ (i : ι), β i
i : ι
⊢ (erase i f) i = (f - single i (f i)) i
state_after: no goals

tactic: simp [erase_ne h.symm, single_eq_of_ne h, @eq_comm _ j, h]
state_before: case h.inr
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddGroup (β i)
f : Π₀ (i : ι), β i
i j : ι
h : i ≠ j
⊢ (erase i f) j = (f - single i (f i)) j
state_after: no goals
Theorem: List.length_sym2
File: Mathlib/Data/List/Sym.lean

tactic: induction xs with
| nil => rfl
| cons x xs ih =>
  rw [List.sym2, length_append, length_map, length_cons,
      Nat.choose_succ_succ, ← ih, Nat.choose_one_right]
state_before: α : Type u_1
xs : List α
⊢ xs.sym2.length = (xs.length + 1).choose 2
state_after: no goals

tactic: rfl
state_before: case nil
α : Type u_1
⊢ [].sym2.length = ([].length + 1).choose 2
state_after: no goals

tactic: rw [List.sym2, length_append, length_map, length_cons,
    Nat.choose_succ_succ, ← ih, Nat.choose_one_right]
state_before: case cons
α : Type u_1
x : α
xs : List α
ih : xs.sym2.length = (xs.length + 1).choose 2
⊢ (x :: xs).sym2.length = ((x :: xs).length + 1).choose 2
state_after: no goals
Theorem: FirstOrder.Language.DirectLimit.Equiv_isup_symm_inclusion
File: Mathlib/ModelTheory/DirectLimit.lean

tactic: ext x
state_before: L : Language
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝³ : Nonempty ι
inst✝² : IsDirected ι fun x x_1 => x ≤ x_1
M : Type u_1
N : Type u_2
inst✝¹ : L.Structure M
inst✝ : L.Structure N
S : ι →o L.Substructure M
i : ι
⊢ (Equiv_iSup S).symm.toEmbedding.comp (Substructure.inclusion ⋯) =
    of L ι (fun x => ↥(S x)) (fun x x_1 h => Substructure.inclusion ⋯) i
state_after: case h
L : Language
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝³ : Nonempty ι
inst✝² : IsDirected ι fun x x_1 => x ≤ x_1
M : Type u_1
N : Type u_2
inst✝¹ : L.Structure M
inst✝ : L.Structure N
S : ι →o L.Substructure M
i : ι
x : ↥(S i)
⊢ ((Equiv_iSup S).symm.toEmbedding.comp (Substructure.inclusion ⋯)) x =
    (of L ι (fun x => ↥(S x)) (fun x x_1 h => Substructure.inclusion ⋯) i) x

tactic: exact Equiv_isup_symm_inclusion_apply _ x
state_before: case h
L : Language
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝³ : Nonempty ι
inst✝² : IsDirected ι fun x x_1 => x ≤ x_1
M : Type u_1
N : Type u_2
inst✝¹ : L.Structure M
inst✝ : L.Structure N
S : ι →o L.Substructure M
i : ι
x : ↥(S i)
⊢ ((Equiv_iSup S).symm.toEmbedding.comp (Substructure.inclusion ⋯)) x =
    (of L ι (fun x => ↥(S x)) (fun x x_1 h => Substructure.inclusion ⋯) i) x
state_after: no goals
Theorem: Nat.Partrec.Code.encode_lt_prec
File: Mathlib/Computability/PartrecCode.lean

tactic: have : encode (pair cf cg) < encode (prec cf cg) := by simp [encodeCode_eq, encodeCode]
state_before: cf cg : Code
⊢ encode cf < encode (cf.prec cg) ∧ encode cg < encode (cf.prec cg)
state_after: cf cg : Code
this : encode (cf.pair cg) < encode (cf.prec cg)
⊢ encode cf < encode (cf.prec cg) ∧ encode cg < encode (cf.prec cg)

tactic: exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this
state_before: cf cg : Code
this : encode (cf.pair cg) < encode (cf.prec cg)
⊢ encode cf < encode (cf.prec cg) ∧ encode cg < encode (cf.prec cg)
state_after: no goals

tactic: simp [encodeCode_eq, encodeCode]
state_before: cf cg : Code
⊢ encode (cf.pair cg) < encode (cf.prec cg)
state_after: no goals
Theorem: QuotientGroup.rightRel_eq
File: Mathlib/GroupTheory/Coset.lean

tactic: simp only [eq_iff_iff]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
⊢ ∀ (a b : α), Setoid.r a b = (b * a⁻¹ ∈ s)
state_after: α : Type u_1
inst✝ : Group α
s : Subgroup α
⊢ ∀ (a b : α), Setoid.r a b ↔ b * a⁻¹ ∈ s

tactic: apply rightRel_apply
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
⊢ ∀ (a b : α), Setoid.r a b ↔ b * a⁻¹ ∈ s
state_after: no goals
Theorem: dist_lineMap_left
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

tactic: simpa only [lineMap_apply_zero, dist_zero_right] using dist_lineMap_lineMap p₁ p₂ c 0
state_before: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
p₁ p₂ : P
c : 𝕜
⊢ dist ((lineMap p₁ p₂) c) p₁ = ‖c‖ * dist p₁ p₂
state_after: no goals
Theorem: IsAdjoinRoot.aequiv_self
File: Mathlib/RingTheory/IsAdjoinRoot.lean

tactic: ext a
state_before: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
⊢ h.aequiv h = AlgEquiv.refl
state_after: case h
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
a : S
⊢ (h.aequiv h) a = AlgEquiv.refl a

tactic: exact h.lift_self_apply a
state_before: case h
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
a : S
⊢ (h.aequiv h) a = AlgEquiv.refl a
state_after: no goals
Theorem: ContinuousAffineMap.mk_coe
File: Mathlib/Topology/Algebra/ContinuousAffineMap.lean

tactic: ext
state_before: R : Type u_1
V : Type u_2
W : Type u_3
P : Type u_4
Q : Type u_5
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module R V
inst✝⁵ : TopologicalSpace P
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup W
inst✝² : Module R W
inst✝¹ : TopologicalSpace Q
inst✝ : AddTorsor W Q
f : P →ᴬ[R] Q
h : Continuous f.toFun
⊢ { toAffineMap := f.toAffineMap, cont := h } = f
state_after: case h
R : Type u_1
V : Type u_2
W : Type u_3
P : Type u_4
Q : Type u_5
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module R V
inst✝⁵ : TopologicalSpace P
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup W
inst✝² : Module R W
inst✝¹ : TopologicalSpace Q
inst✝ : AddTorsor W Q
f : P →ᴬ[R] Q
h : Continuous f.toFun
x✝ : P
⊢ { toAffineMap := f.toAffineMap, cont := h } x✝ = f x✝

tactic: rfl
state_before: case h
R : Type u_1
V : Type u_2
W : Type u_3
P : Type u_4
Q : Type u_5
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module R V
inst✝⁵ : TopologicalSpace P
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup W
inst✝² : Module R W
inst✝¹ : TopologicalSpace Q
inst✝ : AddTorsor W Q
f : P →ᴬ[R] Q
h : Continuous f.toFun
x✝ : P
⊢ { toAffineMap := f.toAffineMap, cont := h } x✝ = f x✝
state_after: no goals
Theorem: mul_sub_left_distrib
File: Mathlib/Algebra/Ring/Defs.lean

tactic: simpa only [sub_eq_add_neg, neg_mul_eq_mul_neg] using mul_add a b (-c)
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonUnitalNonAssocRing α
a b c : α
⊢ a * (b - c) = a * b - a * c
state_after: no goals
Theorem: EuclideanGeometry.sin_angle_mul_dist_of_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [angle, ← inner_eq_zero_iff_angle_eq_pi_div_two, real_inner_comm, ← neg_eq_zero, ←
  inner_neg_left, neg_vsub_eq_vsub_rev] at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ∠ p₁ p₂ p₃ = π / 2
⊢ Real.sin (∠ p₂ p₃ p₁) * dist p₁ p₃ = dist p₁ p₂
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
⊢ Real.sin (∠ p₂ p₃ p₁) * dist p₁ p₃ = dist p₁ p₂

tactic: rw [angle, dist_eq_norm_vsub V p₁ p₂, dist_eq_norm_vsub V p₁ p₃, ← vsub_add_vsub_cancel p₁ p₂ p₃,
  add_comm, sin_angle_add_mul_norm_of_inner_eq_zero h]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
⊢ Real.sin (∠ p₂ p₃ p₁) * dist p₁ p₃ = dist p₁ p₂
state_after: no goals
Theorem: lt_of_strongLT
File: Mathlib/Order/Basic.lean

tactic: inhabit ι
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝¹ : (i : ι) → Preorder (π i)
a b c : (i : ι) → π i
inst✝ : Nonempty ι
h : a ≺ b
⊢ a < b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝¹ : (i : ι) → Preorder (π i)
a b c : (i : ι) → π i
inst✝ : Nonempty ι
h : a ≺ b
inhabited_h : Inhabited ι
⊢ a < b

tactic: exact Pi.lt_def.2 ⟨le_of_strongLT h, default, h _⟩
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝¹ : (i : ι) → Preorder (π i)
a b c : (i : ι) → π i
inst✝ : Nonempty ι
h : a ≺ b
inhabited_h : Inhabited ι
⊢ a < b
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.Point.toAffine_of_Z_eq_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rw [toAffine, dif_neg <| not_and_not_right.mpr fun _ => hPz]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z = 0
⊢ toAffine W P = 0
state_after: no goals