ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: WeierstrassCurve.Jacobian.addX_smul
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
u v : R
⊢ W'.addX (u • P) (v • Q) = ((u * v) ^ 2) ^ 2 * W'.addX P Q
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
u v : R
⊢ u ^ 2 * P x * (v ^ 2 * Q x) ^ 2 * (u * P z) ^ 2 - 2 * (u ^ 3 * P y) * (v ^ 3 * Q y) * (u * P z) * (v * Q z) +
                      (u ^ 2 * P x) ^ 2 * (v ^ 2 * Q x) * (v * Q z) ^ 2 -
                    W'.a₁ * (u ^ 2 * P x) * (v ^ 3 * Q y) * (u * P z) ^ 2 * (v * Q z) -
                  W'.a₁ * (u ^ 3 * P y) * (v ^ 2 * Q x) * (u * P z) * (v * Q z) ^ 2 +
                2 * W'.a₂ * (u ^ 2 * P x) * (v ^ 2 * Q x) * (u * P z) ^ 2 * (v * Q z) ^ 2 -
              W'.a₃ * (v ^ 3 * Q y) * (u * P z) ^ 4 * (v * Q z) -
            W'.a₃ * (u ^ 3 * P y) * (u * P z) * (v * Q z) ^ 4 +
          W'.a₄ * (v ^ 2 * Q x) * (u * P z) ^ 4 * (v * Q z) ^ 2 +
        W'.a₄ * (u ^ 2 * P x) * (u * P z) ^ 2 * (v * Q z) ^ 4 +
      2 * W'.a₆ * (u * P z) ^ 4 * (v * Q z) ^ 4 =
    ((u * v) ^ 2) ^ 2 *
      (P x * Q x ^ 2 * P z ^ 2 - 2 * P y * Q y * P z * Q z + P x ^ 2 * Q x * Q z ^ 2 -
                      W'.a₁ * P x * Q y * P z ^ 2 * Q z -
                    W'.a₁ * P y * Q x * P z * Q z ^ 2 +
                  2 * W'.a₂ * P x * Q x * P z ^ 2 * Q z ^ 2 -
                W'.a₃ * Q y * P z ^ 4 * Q z -
              W'.a₃ * P y * P z * Q z ^ 4 +
            W'.a₄ * Q x * P z ^ 4 * Q z ^ 2 +
          W'.a₄ * P x * P z ^ 2 * Q z ^ 4 +
        2 * W'.a₆ * P z ^ 4 * Q z ^ 4)
tactic: simp only [addX, smul_fin3_ext]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
u v : R
⊢ u ^ 2 * P x * (v ^ 2 * Q x) ^ 2 * (u * P z) ^ 2 - 2 * (u ^ 3 * P y) * (v ^ 3 * Q y) * (u * P z) * (v * Q z) +
                      (u ^ 2 * P x) ^ 2 * (v ^ 2 * Q x) * (v * Q z) ^ 2 -
                    W'.a₁ * (u ^ 2 * P x) * (v ^ 3 * Q y) * (u * P z) ^ 2 * (v * Q z) -
                  W'.a₁ * (u ^ 3 * P y) * (v ^ 2 * Q x) * (u * P z) * (v * Q z) ^ 2 +
                2 * W'.a₂ * (u ^ 2 * P x) * (v ^ 2 * Q x) * (u * P z) ^ 2 * (v * Q z) ^ 2 -
              W'.a₃ * (v ^ 3 * Q y) * (u * P z) ^ 4 * (v * Q z) -
            W'.a₃ * (u ^ 3 * P y) * (u * P z) * (v * Q z) ^ 4 +
          W'.a₄ * (v ^ 2 * Q x) * (u * P z) ^ 4 * (v * Q z) ^ 2 +
        W'.a₄ * (u ^ 2 * P x) * (u * P z) ^ 2 * (v * Q z) ^ 4 +
      2 * W'.a₆ * (u * P z) ^ 4 * (v * Q z) ^ 4 =
    ((u * v) ^ 2) ^ 2 *
      (P x * Q x ^ 2 * P z ^ 2 - 2 * P y * Q y * P z * Q z + P x ^ 2 * Q x * Q z ^ 2 -
                      W'.a₁ * P x * Q y * P z ^ 2 * Q z -
                    W'.a₁ * P y * Q x * P z * Q z ^ 2 +
                  2 * W'.a₂ * P x * Q x * P z ^ 2 * Q z ^ 2 -
                W'.a₃ * Q y * P z ^ 4 * Q z -
              W'.a₃ * P y * P z * Q z ^ 4 +
            W'.a₄ * Q x * P z ^ 4 * Q z ^ 2 +
          W'.a₄ * P x * P z ^ 2 * Q z ^ 4 +
        2 * W'.a₆ * P z ^ 4 * Q z ^ 4)
state_after: no goals
tactic: ring1
Theorem: Seminorm.closedBall_smul
File: Mathlib/Analysis/Seminorm.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p✝ : Seminorm 𝕜 E
x✝ y : E
r✝ : ℝ
p : Seminorm 𝕜 E
c : ℝ≥0
hc : 0 < c
r : ℝ
x : E
⊢ (c • p).closedBall x r = p.closedBall x (r / ↑c)
state_after: case h
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p✝ : Seminorm 𝕜 E
x✝¹ y : E
r✝ : ℝ
p : Seminorm 𝕜 E
c : ℝ≥0
hc : 0 < c
r : ℝ
x x✝ : E
⊢ x✝ ∈ (c • p).closedBall x r ↔ x✝ ∈ p.closedBall x (r / ↑c)
tactic: ext
state_before: case h
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p✝ : Seminorm 𝕜 E
x✝¹ y : E
r✝ : ℝ
p : Seminorm 𝕜 E
c : ℝ≥0
hc : 0 < c
r : ℝ
x x✝ : E
⊢ x✝ ∈ (c • p).closedBall x r ↔ x✝ ∈ p.closedBall x (r / ↑c)
state_after: no goals
tactic: rw [mem_closedBall, mem_closedBall, smul_apply, NNReal.smul_def, smul_eq_mul, mul_comm,
    le_div_iff (NNReal.coe_pos.mpr hc)]
Theorem: Nat.primeFactors_mul
File: Mathlib/Data/Nat/PrimeFin.lean

Proof steps:
state_before: a b k m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ (a * b).primeFactors = a.primeFactors ∪ b.primeFactors
state_after: case a
a b k m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
a✝ : ℕ
⊢ a✝ ∈ (a * b).primeFactors ↔ a✝ ∈ a.primeFactors ∪ b.primeFactors
tactic: ext
state_before: case a
a b k m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
a✝ : ℕ
⊢ a✝ ∈ (a * b).primeFactors ↔ a✝ ∈ a.primeFactors ∪ b.primeFactors
state_after: no goals
tactic: simp only [Finset.mem_union, mem_primeFactors_iff_mem_primeFactorsList,
    mem_primeFactorsList_mul ha hb]
Theorem: Polynomial.content_eq_gcd_range_of_lt
File: Mathlib/RingTheory/Polynomial/Content.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
n : ℕ
h : p.natDegree < n
⊢ p.content = (Finset.range n).gcd p.coeff
state_after: case hab
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
n : ℕ
h : p.natDegree < n
⊢ p.content ∣ (Finset.range n).gcd p.coeff

case hba
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
n : ℕ
h : p.natDegree < n
⊢ (Finset.range n).gcd p.coeff ∣ p.content
tactic: apply dvd_antisymm_of_normalize_eq normalize_content Finset.normalize_gcd
Theorem: Equiv.Perm.cycleFactorsFinset_eq_finset
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f σ : Perm α
s : Finset (Perm α)
⊢ σ.cycleFactorsFinset = s ↔ (∀ f ∈ s, f.IsCycle) ∧ ∃ (h : (↑s).Pairwise Disjoint), s.noncommProd id ⋯ = σ
state_after: case intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f σ : Perm α
l : List (Perm α)
hl : l.Nodup
⊢ σ.cycleFactorsFinset = l.toFinset ↔
    (∀ f ∈ l.toFinset, f.IsCycle) ∧ ∃ (h : (↑l.toFinset).Pairwise Disjoint), l.toFinset.noncommProd id ⋯ = σ
tactic: obtain ⟨l, hl, rfl⟩ := s.exists_list_nodup_eq
state_before: case intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f σ : Perm α
l : List (Perm α)
hl : l.Nodup
⊢ σ.cycleFactorsFinset = l.toFinset ↔
    (∀ f ∈ l.toFinset, f.IsCycle) ∧ ∃ (h : (↑l.toFinset).Pairwise Disjoint), l.toFinset.noncommProd id ⋯ = σ
state_after: no goals
tactic: simp [cycleFactorsFinset_eq_list_toFinset, hl]
Theorem: IsCompact.mul_closure_one_eq_closure
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t K : Set G
hK : IsCompact K
⊢ K * closure {1} = closure K
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t K : Set G
hK : IsCompact K
⊢ K * closure {1} ⊆ closure K

G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t K : Set G
hK : IsCompact K
⊢ closure K ⊆ K * closure {1}
tactic: apply Subset.antisymm ?_ ?_
Theorem: Setoid.sup_eq_eqvGen
File: Mathlib/Data/Setoid/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r s : Setoid α
⊢ r ⊔ s = EqvGen.Setoid fun x y => r.Rel x y ∨ s.Rel x y
state_after: α : Type u_1
β : Type u_2
r s : Setoid α
⊢ r ⊔ s = sInf {s_1 | ∀ ⦃x y : α⦄, r.Rel x y ∨ s.Rel x y → s_1.Rel x y}
tactic: rw [eqvGen_eq]
state_before: α : Type u_1
β : Type u_2
r s : Setoid α
⊢ r ⊔ s = sInf {s_1 | ∀ ⦃x y : α⦄, r.Rel x y ∨ s.Rel x y → s_1.Rel x y}
state_after: α : Type u_1
β : Type u_2
r s : Setoid α
⊢ {x | r ≤ x ∧ s ≤ x} = {s_1 | ∀ ⦃x y : α⦄, r.Rel x y ∨ s.Rel x y → s_1.Rel x y}
tactic: apply congr_arg sInf
state_before: α : Type u_1
β : Type u_2
r s : Setoid α
⊢ {x | r ≤ x ∧ s ≤ x} = {s_1 | ∀ ⦃x y : α⦄, r.Rel x y ∨ s.Rel x y → s_1.Rel x y}
state_after: no goals
tactic: simp only [le_def, or_imp, ← forall_and]
Theorem: FormalMultilinearSeries.compContinuousLinearMap_applyComposition
File: Mathlib/Analysis/Analytic/Composition.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝¹⁵ : CommRing 𝕜
inst✝¹⁴ : AddCommGroup E
inst✝¹³ : AddCommGroup F
inst✝¹² : AddCommGroup G
inst✝¹¹ : Module 𝕜 E
inst✝¹⁰ : Module 𝕜 F
inst✝⁹ : Module 𝕜 G
inst✝⁸ : TopologicalSpace E
inst✝⁷ : TopologicalSpace F
inst✝⁶ : TopologicalSpace G
inst✝⁵ : TopologicalAddGroup E
inst✝⁴ : ContinuousConstSMul 𝕜 E
inst✝³ : TopologicalAddGroup F
inst✝² : ContinuousConstSMul 𝕜 F
inst✝¹ : TopologicalAddGroup G
inst✝ : ContinuousConstSMul 𝕜 G
n : ℕ
p : FormalMultilinearSeries 𝕜 F G
f : E →L[𝕜] F
c : Composition n
v : Fin n → E
⊢ (p.compContinuousLinearMap f).applyComposition c v = p.applyComposition c (⇑f ∘ v)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝¹⁵ : CommRing 𝕜
inst✝¹⁴ : AddCommGroup E
inst✝¹³ : AddCommGroup F
inst✝¹² : AddCommGroup G
inst✝¹¹ : Module 𝕜 E
inst✝¹⁰ : Module 𝕜 F
inst✝⁹ : Module 𝕜 G
inst✝⁸ : TopologicalSpace E
inst✝⁷ : TopologicalSpace F
inst✝⁶ : TopologicalSpace G
inst✝⁵ : TopologicalAddGroup E
inst✝⁴ : ContinuousConstSMul 𝕜 E
inst✝³ : TopologicalAddGroup F
inst✝² : ContinuousConstSMul 𝕜 F
inst✝¹ : TopologicalAddGroup G
inst✝ : ContinuousConstSMul 𝕜 G
n : ℕ
p : FormalMultilinearSeries 𝕜 F G
f : E →L[𝕜] F
c : Composition n
v : Fin n → E
⊢ (fun i => (p (c.blocksFun i)) (⇑f ∘ v ∘ ⇑(c.embedding i))) = fun i =>
    (p (c.blocksFun i)) ((⇑f ∘ v) ∘ ⇑(c.embedding i))
tactic: simp (config := {unfoldPartialApp := true}) [applyComposition]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝¹⁵ : CommRing 𝕜
inst✝¹⁴ : AddCommGroup E
inst✝¹³ : AddCommGroup F
inst✝¹² : AddCommGroup G
inst✝¹¹ : Module 𝕜 E
inst✝¹⁰ : Module 𝕜 F
inst✝⁹ : Module 𝕜 G
inst✝⁸ : TopologicalSpace E
inst✝⁷ : TopologicalSpace F
inst✝⁶ : TopologicalSpace G
inst✝⁵ : TopologicalAddGroup E
inst✝⁴ : ContinuousConstSMul 𝕜 E
inst✝³ : TopologicalAddGroup F
inst✝² : ContinuousConstSMul 𝕜 F
inst✝¹ : TopologicalAddGroup G
inst✝ : ContinuousConstSMul 𝕜 G
n : ℕ
p : FormalMultilinearSeries 𝕜 F G
f : E →L[𝕜] F
c : Composition n
v : Fin n → E
⊢ (fun i => (p (c.blocksFun i)) (⇑f ∘ v ∘ ⇑(c.embedding i))) = fun i =>
    (p (c.blocksFun i)) ((⇑f ∘ v) ∘ ⇑(c.embedding i))
state_after: no goals
tactic: rfl
Theorem: toZ_iterate_pred_ge
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

Proof steps:
state_before: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
n : ℕ
⊢ -↑n ≤ toZ i0 (pred^[n] i0)
state_after: case inl
ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
n : ℕ
h : i0 ≤ pred^[n] i0
⊢ -↑n ≤ toZ i0 (pred^[n] i0)

case inr
ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
n : ℕ
h : pred^[n] i0 < i0
⊢ -↑n ≤ toZ i0 (pred^[n] i0)
tactic: rcases le_or_lt i0 (pred^[n] i0) with h | h
Theorem: HNNExtension.of_mul_t
File: Mathlib/GroupTheory/HNNExtension.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
b : ↥B
⊢ of ↑b * t = t * of ↑(φ.symm b)
state_after: G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
b : ↥B
⊢ of ↑b * t = of ↑(φ (φ.symm b)) * t
tactic: rw [t_mul_of]
state_before: G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
b : ↥B
⊢ of ↑b * t = of ↑(φ (φ.symm b)) * t
state_after: no goals
tactic: simp
Theorem: List.Duplicate.mem
File: Mathlib/Data/List/Duplicate.lean

Proof steps:
state_before: α : Type u_1
l : List α
x : α
h : x ∈+ l
⊢ x ∈ l
state_after: case cons_mem
α : Type u_1
l : List α
x : α
l' : List α
a✝ : x ∈ l'
⊢ x ∈ x :: l'

case cons_duplicate
α : Type u_1
l : List α
x y : α
l' : List α
a✝ : x ∈+ l'
hm : x ∈ l'
⊢ x ∈ y :: l'
tactic: induction' h with l' _ y l' _ hm
Theorem: Multiset.disjoint_add_left
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
s t u : Multiset α
⊢ (s + t).Disjoint u ↔ s.Disjoint u ∧ t.Disjoint u
state_after: no goals
tactic: simp [Disjoint, or_imp, forall_and]
Theorem: AffineSubspace.inter_nonempty_of_nonempty_of_sup_direction_eq_top
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
h1 : (↑s1).Nonempty
h2 : (↑s2).Nonempty
hd : s1.direction ⊔ s2.direction = ⊤
⊢ (↑s1 ∩ ↑s2).Nonempty
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
h1 : (↑s1).Nonempty
h2 : (↑s2).Nonempty
hd : s1.direction ⊔ s2.direction = ⊤
h : ¬(↑s1 ∩ ↑s2).Nonempty
⊢ False
tactic: by_contra h
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
h1 : (↑s1).Nonempty
h2 : (↑s2).Nonempty
hd : s1.direction ⊔ s2.direction = ⊤
h : ¬(↑s1 ∩ ↑s2).Nonempty
⊢ False
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
h1 : (↑s1).Nonempty
h2 : (↑s2).Nonempty
hd : s1.direction ⊔ s2.direction = ⊤
h : ↑s1 ∩ ↑s2 = ∅
⊢ False
tactic: rw [Set.not_nonempty_iff_eq_empty] at h
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
h1 : (↑s1).Nonempty
h2 : (↑s2).Nonempty
hd : s1.direction ⊔ s2.direction = ⊤
h : ↑s1 ∩ ↑s2 = ∅
⊢ False
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
h1 : (↑s1).Nonempty
h2 : (↑s2).Nonempty
hd : s1.direction ⊔ s2.direction = ⊤
h : ↑s1 ∩ ↑s2 = ∅
hlt : s1.direction ⊔ s2.direction < (s1 ⊔ s2).direction
⊢ False
tactic: have hlt := sup_direction_lt_of_nonempty_of_inter_empty h1 h2 h
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
h1 : (↑s1).Nonempty
h2 : (↑s2).Nonempty
hd : s1.direction ⊔ s2.direction = ⊤
h : ↑s1 ∩ ↑s2 = ∅
hlt : s1.direction ⊔ s2.direction < (s1 ⊔ s2).direction
⊢ False
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
h1 : (↑s1).Nonempty
h2 : (↑s2).Nonempty
hd : s1.direction ⊔ s2.direction = ⊤
h : ↑s1 ∩ ↑s2 = ∅
hlt : ⊤ < (s1 ⊔ s2).direction
⊢ False
tactic: rw [hd] at hlt
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
h1 : (↑s1).Nonempty
h2 : (↑s2).Nonempty
hd : s1.direction ⊔ s2.direction = ⊤
h : ↑s1 ∩ ↑s2 = ∅
hlt : ⊤ < (s1 ⊔ s2).direction
⊢ False
state_after: no goals
tactic: exact not_top_lt hlt
Theorem: MeasureTheory.Measure.measure_preimage_of_map_eq_self
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f✝ : α → β
f : α → α
hf : map f μ = μ
s : Set α
hs : NullMeasurableSet s μ
⊢ μ (f ⁻¹' s) = μ s
state_after: no goals
tactic: if hfm : AEMeasurable f μ then
    rw [← map_apply₀ hfm, hf]
    rwa [hf]
  else
    rw [map_of_not_aemeasurable hfm] at hf
    simp [← hf]
Theorem: Submodule.disjoint_def
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p✝ q p p' : Submodule R M
⊢ (∀ (x : M), x ∈ p ∧ x ∈ p' → x ∈ {0}) ↔ ∀ x ∈ p, x ∈ p' → x = 0
state_after: no goals
tactic: simp
Theorem: MeasurableEquiv.image_preimage
File: Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
e : α ≃ᵐ β
s : Set β
⊢ ⇑e '' (⇑e ⁻¹' s) = s
state_after: no goals
tactic: rw [← coe_toEquiv, Equiv.image_preimage]
Theorem: CategoryTheory.Arrow.mapCechNerve_app
File: Mathlib/AlgebraicTopology/CechNerve.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
f✝ : Arrow C
inst✝² : ∀ (n : ℕ), HasWidePullback f✝.right (fun x => f✝.left) fun x => f✝.hom
f g : Arrow C
inst✝¹ : ∀ (n : ℕ), HasWidePullback f.right (fun x => f.left) fun x => f.hom
inst✝ : ∀ (n : ℕ), HasWidePullback g.right (fun x => g.left) fun x => g.hom
F : f ⟶ g
n : SimplexCategoryᵒᵖ
j : Fin ((Opposite.unop n).len + 1)
⊢ (fun i => WidePullback.π (fun x => f.hom) i ≫ F.left) j ≫ g.hom = (WidePullback.base fun x => f.hom) ≫ F.right
state_after: no goals
tactic: simp
Theorem: ModuleCat.directLimitCocone_pt
File: Mathlib/Algebra/Category/ModuleCat/Limits.lean

Proof steps:
state_before: R : Type u
inst✝⁶ : Ring R
J : Type v
inst✝⁵ : Category.{t, v} J
F : J ⥤ ModuleCat R
ι : Type v
dec_ι : DecidableEq ι
inst✝⁴ : Preorder ι
G : ι → Type v
inst✝³ : (i : ι) → AddCommGroup (G i)
inst✝² : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
inst✝¹ : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝ : DecidableEq ι
x✝¹ x✝ : ι
hij : x✝¹ ⟶ x✝
⊢ (directLimitDiagram G f).map hij ≫ DirectLimit.of R ι G f x✝ =
    DirectLimit.of R ι G f x✝¹ ≫ ((Functor.const ι).obj (of R (DirectLimit G f))).map hij
state_after: case h
R : Type u
inst✝⁶ : Ring R
J : Type v
inst✝⁵ : Category.{t, v} J
F : J ⥤ ModuleCat R
ι : Type v
dec_ι : DecidableEq ι
inst✝⁴ : Preorder ι
G : ι → Type v
inst✝³ : (i : ι) → AddCommGroup (G i)
inst✝² : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
inst✝¹ : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝ : DecidableEq ι
x✝¹ x✝ : ι
hij : x✝¹ ⟶ x✝
⊢ ∀ (x : ↑((directLimitDiagram G f).obj x✝¹)),
    ((directLimitDiagram G f).map hij ≫ DirectLimit.of R ι G f x✝) x =
      (DirectLimit.of R ι G f x✝¹ ≫ ((Functor.const ι).obj (of R (DirectLimit G f))).map hij) x
tactic: apply LinearMap.ext
state_before: case h
R : Type u
inst✝⁶ : Ring R
J : Type v
inst✝⁵ : Category.{t, v} J
F : J ⥤ ModuleCat R
ι : Type v
dec_ι : DecidableEq ι
inst✝⁴ : Preorder ι
G : ι → Type v
inst✝³ : (i : ι) → AddCommGroup (G i)
inst✝² : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
inst✝¹ : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝ : DecidableEq ι
x✝¹ x✝ : ι
hij : x✝¹ ⟶ x✝
⊢ ∀ (x : ↑((directLimitDiagram G f).obj x✝¹)),
    ((directLimitDiagram G f).map hij ≫ DirectLimit.of R ι G f x✝) x =
      (DirectLimit.of R ι G f x✝¹ ≫ ((Functor.const ι).obj (of R (DirectLimit G f))).map hij) x
state_after: case h
R : Type u
inst✝⁶ : Ring R
J : Type v
inst✝⁵ : Category.{t, v} J
F : J ⥤ ModuleCat R
ι : Type v
dec_ι : DecidableEq ι
inst✝⁴ : Preorder ι
G : ι → Type v
inst✝³ : (i : ι) → AddCommGroup (G i)
inst✝² : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
inst✝¹ : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝ : DecidableEq ι
x✝¹ x✝ : ι
hij : x✝¹ ⟶ x✝
x : ↑((directLimitDiagram G f).obj x✝¹)
⊢ ((directLimitDiagram G f).map hij ≫ DirectLimit.of R ι G f x✝) x =
    (DirectLimit.of R ι G f x✝¹ ≫ ((Functor.const ι).obj (of R (DirectLimit G f))).map hij) x
tactic: intro x
state_before: case h
R : Type u
inst✝⁶ : Ring R
J : Type v
inst✝⁵ : Category.{t, v} J
F : J ⥤ ModuleCat R
ι : Type v
dec_ι : DecidableEq ι
inst✝⁴ : Preorder ι
G : ι → Type v
inst✝³ : (i : ι) → AddCommGroup (G i)
inst✝² : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
inst✝¹ : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝ : DecidableEq ι
x✝¹ x✝ : ι
hij : x✝¹ ⟶ x✝
x : ↑((directLimitDiagram G f).obj x✝¹)
⊢ ((directLimitDiagram G f).map hij ≫ DirectLimit.of R ι G f x✝) x =
    (DirectLimit.of R ι G f x✝¹ ≫ ((Functor.const ι).obj (of R (DirectLimit G f))).map hij) x
state_after: no goals
tactic: exact DirectLimit.of_f
Theorem: Equiv.prodShear_apply
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α₁ : Type ?u.41768
β₁ : Type ?u.41767
β₂ : Type ?u.41769
e : α₁ → β₁ ≃ β₂
α₂ : Type ?u.41770
e₁ : α₁ ≃ α₂
e₂ : α₁ → β₁ ≃ β₂
⊢ LeftInverse (fun y => (e₁.symm y.1, (e₂ (e₁.symm y.1)).symm y.2)) fun x => (e₁ x.1, (e₂ x.1) x.2)
state_after: case mk
α₁ : Type ?u.41768
β₁ : Type ?u.41767
β₂ : Type ?u.41769
e : α₁ → β₁ ≃ β₂
α₂ : Type ?u.41770
e₁ : α₁ ≃ α₂
e₂ : α₁ → β₁ ≃ β₂
x₁ : α₁
y₁ : β₁
⊢ (fun y => (e₁.symm y.1, (e₂ (e₁.symm y.1)).symm y.2)) ((fun x => (e₁ x.1, (e₂ x.1) x.2)) (x₁, y₁)) = (x₁, y₁)
tactic: rintro ⟨x₁, y₁⟩
state_before: case mk
α₁ : Type ?u.41768
β₁ : Type ?u.41767
β₂ : Type ?u.41769
e : α₁ → β₁ ≃ β₂
α₂ : Type ?u.41770
e₁ : α₁ ≃ α₂
e₂ : α₁ → β₁ ≃ β₂
x₁ : α₁
y₁ : β₁
⊢ (fun y => (e₁.symm y.1, (e₂ (e₁.symm y.1)).symm y.2)) ((fun x => (e₁ x.1, (e₂ x.1) x.2)) (x₁, y₁)) = (x₁, y₁)
state_after: no goals
tactic: simp only [symm_apply_apply]
state_before: α₁ : Type ?u.41768
β₁ : Type ?u.41767
β₂ : Type ?u.41769
e : α₁ → β₁ ≃ β₂
α₂ : Type ?u.41770
e₁ : α₁ ≃ α₂
e₂ : α₁ → β₁ ≃ β₂
⊢ Function.RightInverse (fun y => (e₁.symm y.1, (e₂ (e₁.symm y.1)).symm y.2)) fun x => (e₁ x.1, (e₂ x.1) x.2)
state_after: case mk
α₁ : Type ?u.41768
β₁ : Type ?u.41767
β₂ : Type ?u.41769
e : α₁ → β₁ ≃ β₂
α₂ : Type ?u.41770
e₁ : α₁ ≃ α₂
e₂ : α₁ → β₁ ≃ β₂
x₁ : α₂
y₁ : β₂
⊢ (fun x => (e₁ x.1, (e₂ x.1) x.2)) ((fun y => (e₁.symm y.1, (e₂ (e₁.symm y.1)).symm y.2)) (x₁, y₁)) = (x₁, y₁)
tactic: rintro ⟨x₁, y₁⟩
state_before: case mk
α₁ : Type ?u.41768
β₁ : Type ?u.41767
β₂ : Type ?u.41769
e : α₁ → β₁ ≃ β₂
α₂ : Type ?u.41770
e₁ : α₁ ≃ α₂
e₂ : α₁ → β₁ ≃ β₂
x₁ : α₂
y₁ : β₂
⊢ (fun x => (e₁ x.1, (e₂ x.1) x.2)) ((fun y => (e₁.symm y.1, (e₂ (e₁.symm y.1)).symm y.2)) (x₁, y₁)) = (x₁, y₁)
state_after: no goals
tactic: simp only [apply_symm_apply]
Theorem: isAlgebraic_algebraMap
File: Mathlib/RingTheory/Algebraic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
A : Type v
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : Ring A
inst✝⁴ : Algebra R A
inst✝³ : Algebra R S
inst✝² : Algebra S A
inst✝¹ : IsScalarTower R S A
inst✝ : Nontrivial R
x : R
⊢ (aeval ((algebraMap R A) x)) (X - C x) = 0
state_after: no goals
tactic: rw [_root_.map_sub, aeval_X, aeval_C, sub_self]
Theorem: extChartAt_preimage_mem_nhds'
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : TopologicalSpace H
inst✝⁶ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedSpace 𝕜 E'
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
inst✝¹ : ChartedSpace H M
inst✝ : ChartedSpace H' M'
x x' : M
h : x' ∈ (extChartAt I x).source
ht : t ∈ 𝓝 x'
⊢ x' ∈ (chartAt H x).source
state_after: no goals
tactic: rwa [← extChartAt_source I]