ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsPGroup.exists_fixed_point_of_prime_dvd_card_of_fixed_point
File: Mathlib/GroupTheory/PGroup.lean

Proof steps:
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
inst✝ : Finite α
hpα : p ∣ Nat.card α
a : α
ha : a ∈ fixedPoints G α
⊢ ∃ b ∈ fixedPoints G α, a ≠ b
state_after: p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
inst✝ : Finite α
hpα : p ∣ Nat.card α
a : α
ha : a ∈ fixedPoints G α
hpf : p ∣ Nat.card ↑(fixedPoints G α)
⊢ ∃ b ∈ fixedPoints G α, a ≠ b
tactic: have hpf : p ∣ Nat.card (fixedPoints G α) :=
    Nat.modEq_zero_iff_dvd.mp ((hG.card_modEq_card_fixedPoints α).symm.trans hpα.modEq_zero_nat)
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
inst✝ : Finite α
hpα : p ∣ Nat.card α
a : α
ha : a ∈ fixedPoints G α
hpf : p ∣ Nat.card ↑(fixedPoints G α)
⊢ ∃ b ∈ fixedPoints G α, a ≠ b
state_after: p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
inst✝ : Finite α
hpα : p ∣ Nat.card α
a : α
ha : a ∈ fixedPoints G α
hpf : p ∣ Nat.card ↑(fixedPoints G α)
hα : 1 < Nat.card ↑(fixedPoints G α)
⊢ ∃ b ∈ fixedPoints G α, a ≠ b
tactic: have hα : 1 < Nat.card (fixedPoints G α) :=
    (Fact.out (p := p.Prime)).one_lt.trans_le (Nat.le_of_dvd (Finite.card_pos_iff.2 ⟨⟨a, ha⟩⟩) hpf)
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
inst✝ : Finite α
hpα : p ∣ Nat.card α
a : α
ha : a ∈ fixedPoints G α
hpf : p ∣ Nat.card ↑(fixedPoints G α)
hα : 1 < Nat.card ↑(fixedPoints G α)
⊢ ∃ b ∈ fixedPoints G α, a ≠ b
state_after: p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
inst✝ : Finite α
hpα : p ∣ Nat.card α
a : α
ha : a ∈ fixedPoints G α
hpf : p ∣ Nat.card ↑(fixedPoints G α)
hα : Nontrivial ↑(fixedPoints G α)
⊢ ∃ b ∈ fixedPoints G α, a ≠ b
tactic: rw [Finite.one_lt_card_iff_nontrivial] at hα
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
inst✝ : Finite α
hpα : p ∣ Nat.card α
a : α
ha : a ∈ fixedPoints G α
hpf : p ∣ Nat.card ↑(fixedPoints G α)
hα : Nontrivial ↑(fixedPoints G α)
⊢ ∃ b ∈ fixedPoints G α, a ≠ b
state_after: no goals
tactic: exact
    let ⟨⟨b, hb⟩, hba⟩ := exists_ne (⟨a, ha⟩ : fixedPoints G α)
    ⟨b, hb, fun hab => hba (by simp_rw [hab])⟩
Theorem: CauchySeq.prod_map
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
γ : Type u_1
δ : Type u_2
inst✝² : UniformSpace β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
u : γ → α
v : δ → β
hu : CauchySeq u
hv : CauchySeq v
⊢ CauchySeq (Prod.map u v)
state_after: no goals
tactic: simpa only [CauchySeq, prod_map_map_eq', prod_atTop_atTop_eq] using hu.prod hv
Theorem: ENNReal.natCast_sub
File: Mathlib/Data/ENNReal/Operations.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
m n : ℕ
⊢ ↑(m - n) = ↑m - ↑n
state_after: no goals
tactic: rw [← coe_natCast, Nat.cast_tsub, coe_sub, coe_natCast, coe_natCast]
Theorem: CategoryTheory.GlueData.t'_comp_eq_pullbackSymmetry
File: Mathlib/CategoryTheory/GlueData.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j k : D.J
⊢ D.t' j k i ≫ D.t' k i j =
    (pullbackSymmetry (D.f j k) (D.f j i)).hom ≫ D.t' j i k ≫ (pullbackSymmetry (D.f i k) (D.f i j)).hom
state_after: C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j k : D.J
⊢ D.t' j k i ≫ D.t' k i j = inv (D.t' i j k)

C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j k : D.J
⊢ inv (D.t' i j k) =
    (pullbackSymmetry (D.f j k) (D.f j i)).hom ≫ D.t' j i k ≫ (pullbackSymmetry (D.f i k) (D.f i j)).hom
tactic: trans inv (D.t' i j k)
Theorem: Matrix.inv_zpow'
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

Proof steps:
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit A.det
n : ℤ
⊢ A⁻¹ ^ n = A ^ (-n)
state_after: no goals
tactic: rw [zpow_neg h, inv_zpow]
Theorem: Nat.coprime_mul_left_add_left
File: Mathlib/Data/Nat/GCD/Basic.lean

Proof steps:
state_before: m n k : ℕ
⊢ (n * k + m).Coprime n ↔ m.Coprime n
state_after: no goals
tactic: rw [Coprime, Coprime, gcd_mul_left_add_left]
Theorem: PosNum.sub'_one
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: a : PosNum
⊢ a.sub' 1 = a.pred'.toZNum
state_after: no goals
tactic: cases a <;> rfl
Theorem: SimplicialObject.Splitting.IndexSet.eqId_iff_mono
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.4707, u_1} C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ A.EqId ↔ Mono A.e
state_after: case mp
C : Type u_1
inst✝ : Category.{?u.4707, u_1} C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ A.EqId → Mono A.e

case mpr
C : Type u_1
inst✝ : Category.{?u.4707, u_1} C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ Mono A.e → A.EqId
tactic: constructor
Theorem: Filter.mem_iInf_finset
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
s : Finset α
f : α → Filter β
t : Set β
⊢ t ∈ ⨅ a ∈ s, f a ↔ ∃ p, (∀ a ∈ s, p a ∈ f a) ∧ t = ⋂ a ∈ s, p a
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
s : Finset α
f : α → Filter β
t : Set β
⊢ t ∈ ⨅ x, f ↑x ↔ ∃ p, (∀ a ∈ s, p a ∈ f a) ∧ t = ⋂ x, p ↑x
tactic: simp only [← Finset.set_biInter_coe, biInter_eq_iInter, iInf_subtype']
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
s : Finset α
f : α → Filter β
t : Set β
⊢ t ∈ ⨅ x, f ↑x ↔ ∃ p, (∀ a ∈ s, p a ∈ f a) ∧ t = ⋂ x, p ↑x
state_after: case refine_1
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
s : Finset α
f : α → Filter β
t : Set β
h : t ∈ ⨅ x, f ↑x
⊢ ∃ p, (∀ a ∈ s, p a ∈ f a) ∧ t = ⋂ x, p ↑x

case refine_2
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
s : Finset α
f : α → Filter β
t : Set β
⊢ (∃ p, (∀ a ∈ s, p a ∈ f a) ∧ t = ⋂ x, p ↑x) → t ∈ ⨅ x, f ↑x
tactic: refine ⟨fun h => ?_, ?_⟩
Theorem: MeasureTheory.SignedMeasure.toComplexMeasure_apply_re
File: Mathlib/MeasureTheory/Measure/Complex.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
s t : SignedMeasure α
⊢ (fun i => { re := ↑s i, im := ↑t i }) ∅ = 0
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
s t : SignedMeasure α
⊢ { re := ↑s ∅, im := ↑t ∅ } = 0
tactic: dsimp only
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
s t : SignedMeasure α
⊢ { re := ↑s ∅, im := ↑t ∅ } = 0
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
s t : SignedMeasure α
⊢ { re := 0, im := 0 } = 0
tactic: rw [s.empty, t.empty]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
s t : SignedMeasure α
⊢ { re := 0, im := 0 } = 0
state_after: no goals
tactic: rfl
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
s t : SignedMeasure α
i : Set α
hi : ¬MeasurableSet i
⊢ (fun i => { re := ↑s i, im := ↑t i }) i = 0
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
s t : SignedMeasure α
i : Set α
hi : ¬MeasurableSet i
⊢ { re := ↑s i, im := ↑t i } = 0
tactic: dsimp only
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
s t : SignedMeasure α
i : Set α
hi : ¬MeasurableSet i
⊢ { re := ↑s i, im := ↑t i } = 0
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
s t : SignedMeasure α
i : Set α
hi : ¬MeasurableSet i
⊢ { re := 0, im := 0 } = 0
tactic: rw [s.not_measurable hi, t.not_measurable hi]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
s t : SignedMeasure α
i : Set α
hi : ¬MeasurableSet i
⊢ { re := 0, im := 0 } = 0
state_after: no goals
tactic: rfl
Theorem: MvPolynomial.support_symmDiff_support_subset_support_add
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ p.support ∆ q.support ⊆ (p + q).support
state_after: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ p.support \ q.support ∪ q.support \ p.support ⊆ (p + q).support
tactic: rw [symmDiff_def, Finset.sup_eq_union]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ p.support \ q.support ∪ q.support \ p.support ⊆ (p + q).support
state_after: case hs
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ p.support \ q.support ⊆ (p + q).support

case a
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ q.support \ p.support ⊆ (p + q).support
tactic: apply Finset.union_subset
Theorem: TensorProduct.toDirectLimit_tmul_of
File: Mathlib/LinearAlgebra/TensorProduct/DirectLimit.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : CommRing R
ι : Type u_2
inst✝⁵ : DecidableEq ι
inst✝⁴ : Preorder ι
G : ι → Type u_3
inst✝³ : (i : ι) → AddCommGroup (G i)
inst✝² : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
M : Type u_4
inst✝¹ : AddCommGroup M
inst✝ : Module R M
i : ι
g : G i
m : M
⊢ (toDirectLimit f M) ((of R ι G f i) g ⊗ₜ[R] m) =
    (of R ι (fun x => G x ⊗[R] M) (fun i j h => LinearMap.rTensor M (f i j h)) i) (g ⊗ₜ[R] m)
state_after: R : Type u_1
inst✝⁶ : CommRing R
ι : Type u_2
inst✝⁵ : DecidableEq ι
inst✝⁴ : Preorder ι
G : ι → Type u_3
inst✝³ : (i : ι) → AddCommGroup (G i)
inst✝² : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
M : Type u_4
inst✝¹ : AddCommGroup M
inst✝ : Module R M
i : ι
g : G i
m : M
⊢ (((mk R (G i) M).compr₂ (of R ι (fun _i => G _i ⊗[R] M) (fun _i _j h => LinearMap.rTensor M (f _i _j h)) i)) g) m =
    (of R ι (fun x => G x ⊗[R] M) (fun i j h => LinearMap.rTensor M (f i j h)) i) (g ⊗ₜ[R] m)
tactic: rw [toDirectLimit, lift.tmul, lift_of]
state_before: R : Type u_1
inst✝⁶ : CommRing R
ι : Type u_2
inst✝⁵ : DecidableEq ι
inst✝⁴ : Preorder ι
G : ι → Type u_3
inst✝³ : (i : ι) → AddCommGroup (G i)
inst✝² : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
M : Type u_4
inst✝¹ : AddCommGroup M
inst✝ : Module R M
i : ι
g : G i
m : M
⊢ (((mk R (G i) M).compr₂ (of R ι (fun _i => G _i ⊗[R] M) (fun _i _j h => LinearMap.rTensor M (f _i _j h)) i)) g) m =
    (of R ι (fun x => G x ⊗[R] M) (fun i j h => LinearMap.rTensor M (f i j h)) i) (g ⊗ₜ[R] m)
state_after: no goals
tactic: rfl
Theorem: List.zipWith_distrib_tail
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α✝² : Type u_1
α✝¹ : Type u_2
α✝ : Type u_3
f : α✝² → α✝¹ → α✝
l : List α✝²
l' : List α✝¹
⊢ (zipWith f l l').tail = zipWith f l.tail l'.tail
state_after: α✝² : Type u_1
α✝¹ : Type u_2
α✝ : Type u_3
f : α✝² → α✝¹ → α✝
l : List α✝²
l' : List α✝¹
⊢ drop 1 (zipWith f l l') = zipWith f l.tail l'.tail
tactic: rw [← drop_one]
state_before: α✝² : Type u_1
α✝¹ : Type u_2
α✝ : Type u_3
f : α✝² → α✝¹ → α✝
l : List α✝²
l' : List α✝¹
⊢ drop 1 (zipWith f l l') = zipWith f l.tail l'.tail
state_after: no goals
tactic: simp [zipWith_distrib_drop]
Theorem: CategoryTheory.StructuredArrow.homMk_left
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f f' : StructuredArrow S T
g : f.right ⟶ f'.right
w : autoParam (f.hom ≫ T.map g = f'.hom) _auto✝
⊢ (Functor.fromPUnit S).map (𝟙 f.left) ≫ f'.hom = f.hom ≫ T.map g
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f f' : StructuredArrow S T
g : f.right ⟶ f'.right
w : autoParam (f.hom ≫ T.map g = f'.hom) _auto✝
⊢ 𝟙 S ≫ f'.hom = f.hom ≫ T.map g
tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f f' : StructuredArrow S T
g : f.right ⟶ f'.right
w : autoParam (f.hom ≫ T.map g = f'.hom) _auto✝
⊢ 𝟙 S ≫ f'.hom = f.hom ≫ T.map g
state_after: no goals
tactic: simpa using w.symm
Theorem: MulAction.fixedBy_mem_fixedBy_of_commute
File: Mathlib/GroupTheory/GroupAction/FixedPoints.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
g h : G
comm : Commute g h
⊢ fixedBy α g ∈ fixedBy (Set α) h
state_after: case h
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
g h : G
comm : Commute g h
x : α
⊢ x ∈ h • fixedBy α g ↔ x ∈ fixedBy α g
tactic: ext x
state_before: case h
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
g h : G
comm : Commute g h
x : α
⊢ x ∈ h • fixedBy α g ↔ x ∈ fixedBy α g
state_after: no goals
tactic: rw [Set.mem_smul_set_iff_inv_smul_mem, mem_fixedBy, ← mul_smul, comm.inv_right, mul_smul,
    smul_left_cancel_iff, mem_fixedBy]
Theorem: Polynomial.degree_quadratic_lt_degree_C_mul_X_cb
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
ha : a ≠ 0
⊢ (C b * X ^ 2 + C c * X + C d).degree < (C a * X ^ 3).degree
state_after: no goals
tactic: simpa only [degree_C_mul_X_pow 3 ha] using degree_quadratic_lt
Theorem: AlgebraicGeometry.stalkwiseIsLocalAtTarget_of_respectsIso
File: Mathlib/AlgebraicGeometry/Morphisms/Constructors.lean

Proof steps:
state_before: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RingHom.RespectsIso fun {R S} [CommRing R] [CommRing S] => P
⊢ IsLocalAtTarget (stalkwise fun {R S} [CommRing R] [CommRing S] => P)
state_after: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RingHom.RespectsIso fun {R S} [CommRing R] [CommRing S] => P
hP' : (RingHom.toMorphismProperty fun {R S} [CommRing R] [CommRing S] => P).RespectsIso
⊢ IsLocalAtTarget (stalkwise fun {R S} [CommRing R] [CommRing S] => P)
tactic: have hP' : (RingHom.toMorphismProperty P).RespectsIso :=
    RingHom.toMorphismProperty_respectsIso_iff.mp hP
state_before: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RingHom.RespectsIso fun {R S} [CommRing R] [CommRing S] => P
hP' : (RingHom.toMorphismProperty fun {R S} [CommRing R] [CommRing S] => P).RespectsIso
⊢ IsLocalAtTarget (stalkwise fun {R S} [CommRing R] [CommRing S] => P)
state_after: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RingHom.RespectsIso fun {R S} [CommRing R] [CommRing S] => P
hP' : (RingHom.toMorphismProperty fun {R S} [CommRing R] [CommRing S] => P).RespectsIso
this : (stalkwise fun {R S} [CommRing R] [CommRing S] => P).RespectsIso := stalkwise_respectsIso hP
⊢ IsLocalAtTarget (stalkwise fun {R S} [CommRing R] [CommRing S] => P)
tactic: letI := stalkwise_respectsIso hP
state_before: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RingHom.RespectsIso fun {R S} [CommRing R] [CommRing S] => P
hP' : (RingHom.toMorphismProperty fun {R S} [CommRing R] [CommRing S] => P).RespectsIso
this : (stalkwise fun {R S} [CommRing R] [CommRing S] => P).RespectsIso := stalkwise_respectsIso hP
⊢ IsLocalAtTarget (stalkwise fun {R S} [CommRing R] [CommRing S] => P)
state_after: case restrict
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RingHom.RespectsIso fun {R S} [CommRing R] [CommRing S] => P
hP' : (RingHom.toMorphismProperty fun {R S} [CommRing R] [CommRing S] => P).RespectsIso
this : (stalkwise fun {R S} [CommRing R] [CommRing S] => P).RespectsIso := stalkwise_respectsIso hP
⊢ ∀ {X Y : Scheme} (f : X ⟶ Y) (U : Y.Opens),
    stalkwise (fun {R S} [CommRing R] [CommRing S] => P) f →
      stalkwise (fun {R S} [CommRing R] [CommRing S] => P) (f ∣_ U)

case of_sSup_eq_top
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RingHom.RespectsIso fun {R S} [CommRing R] [CommRing S] => P
hP' : (RingHom.toMorphismProperty fun {R S} [CommRing R] [CommRing S] => P).RespectsIso
this : (stalkwise fun {R S} [CommRing R] [CommRing S] => P).RespectsIso := stalkwise_respectsIso hP
⊢ ∀ {X Y : Scheme} (f : X ⟶ Y) {ι : Type u} (U : ι → Y.Opens),
    iSup U = ⊤ →
      (∀ (i : ι), stalkwise (fun {R S} [CommRing R] [CommRing S] => P) (f ∣_ U i)) →
        stalkwise (fun {R S} [CommRing R] [CommRing S] => P) f
tactic: apply IsLocalAtTarget.mk'
Theorem: continuousAt_sign_of_pos
File: Mathlib/Topology/Instances/Sign.lean

Proof steps:
state_before: α : Type u_1
inst✝⁴ : Zero α
inst✝³ : TopologicalSpace α
inst✝² : PartialOrder α
inst✝¹ : DecidableRel fun x x_1 => x < x_1
inst✝ : OrderTopology α
a : α
h : 0 < a
⊢ ContinuousAt (⇑SignType.sign) a
state_after: α : Type u_1
inst✝⁴ : Zero α
inst✝³ : TopologicalSpace α
inst✝² : PartialOrder α
inst✝¹ : DecidableRel fun x x_1 => x < x_1
inst✝ : OrderTopology α
a : α
h : 0 < a
⊢ (fun x => 1) =ᶠ[nhds a] ⇑SignType.sign
tactic: refine (continuousAt_const : ContinuousAt (fun _ => (1 : SignType)) a).congr ?_
state_before: α : Type u_1
inst✝⁴ : Zero α
inst✝³ : TopologicalSpace α
inst✝² : PartialOrder α
inst✝¹ : DecidableRel fun x x_1 => x < x_1
inst✝ : OrderTopology α
a : α
h : 0 < a
⊢ (fun x => 1) =ᶠ[nhds a] ⇑SignType.sign
state_after: α : Type u_1
inst✝⁴ : Zero α
inst✝³ : TopologicalSpace α
inst✝² : PartialOrder α
inst✝¹ : DecidableRel fun x x_1 => x < x_1
inst✝ : OrderTopology α
a : α
h : 0 < a
⊢ ∃ t, (∀ y ∈ t, 1 = SignType.sign y) ∧ IsOpen t ∧ a ∈ t
tactic: rw [Filter.EventuallyEq, eventually_nhds_iff]
state_before: α : Type u_1
inst✝⁴ : Zero α
inst✝³ : TopologicalSpace α
inst✝² : PartialOrder α
inst✝¹ : DecidableRel fun x x_1 => x < x_1
inst✝ : OrderTopology α
a : α
h : 0 < a
⊢ ∃ t, (∀ y ∈ t, 1 = SignType.sign y) ∧ IsOpen t ∧ a ∈ t
state_after: no goals
tactic: exact ⟨{ x | 0 < x }, fun x hx => (sign_pos hx).symm, isOpen_lt' 0, h⟩
Theorem: SimpleGraph.TripartiteFromTriangles.Graph.in₁₀_iff
File: Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
⊢ (graph t).Adj (in₁ b) (in₀ a) → ∃ c, (a, b, c) ∈ t
state_after: case in₁₀
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
c✝ : γ
a✝ : (a, b, c✝) ∈ t
⊢ ∃ c, (a, b, c) ∈ t
tactic: rintro ⟨⟩
state_before: case in₁₀
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
c✝ : γ
a✝ : (a, b, c✝) ∈ t
⊢ ∃ c, (a, b, c) ∈ t
state_after: no goals
tactic: exact ⟨_, ‹_›⟩
Theorem: SmoothBumpFunction.tsupport_subset_symm_image_closedBall
File: Mathlib/Geometry/Manifold/BumpFunction.lean

Proof steps:
state_before: E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
H : Type uH
inst✝⁴ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
inst✝¹ : SmoothManifoldWithCorners I M
c : M
f : SmoothBumpFunction I c
x : M
inst✝ : T2Space M
⊢ tsupport ↑f ⊆ ↑(extChartAt I c).symm '' (closedBall (↑(extChartAt I c) c) f.rOut ∩ range ↑I)
state_after: E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
H : Type uH
inst✝⁴ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
inst✝¹ : SmoothManifoldWithCorners I M
c : M
f : SmoothBumpFunction I c
x : M
inst✝ : T2Space M
⊢ closure (↑(extChartAt I c).symm '' (ball (↑(extChartAt I c) c) f.rOut ∩ range ↑I)) ⊆
    ↑(extChartAt I c).symm '' (closedBall (↑(extChartAt I c) c) f.rOut ∩ range ↑I)
tactic: rw [tsupport, support_eq_symm_image]
state_before: E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
H : Type uH
inst✝⁴ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
inst✝¹ : SmoothManifoldWithCorners I M
c : M
f : SmoothBumpFunction I c
x : M
inst✝ : T2Space M
⊢ closure (↑(extChartAt I c).symm '' (ball (↑(extChartAt I c) c) f.rOut ∩ range ↑I)) ⊆
    ↑(extChartAt I c).symm '' (closedBall (↑(extChartAt I c) c) f.rOut ∩ range ↑I)
state_after: no goals
tactic: exact closure_minimal (image_subset _ <| inter_subset_inter_left _ ball_subset_closedBall)
    f.isClosed_symm_image_closedBall
Theorem: SimpleGraph.Walk.IsPath.of_append_right
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ u v w : V
p : G.Walk u v
q : G.Walk v w
h : (p.append q).IsPath
⊢ q.IsPath
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ u v w : V
p : G.Walk u v
q : G.Walk v w
h : (p.append q).reverse.IsPath
⊢ q.reverse.IsPath
tactic: rw [← isPath_reverse_iff] at h ⊢
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ u v w : V
p : G.Walk u v
q : G.Walk v w
h : (p.append q).reverse.IsPath
⊢ q.reverse.IsPath
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ u v w : V
p : G.Walk u v
q : G.Walk v w
h : (q.reverse.append p.reverse).IsPath
⊢ q.reverse.IsPath
tactic: rw [reverse_append] at h
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ u v w : V
p : G.Walk u v
q : G.Walk v w
h : (q.reverse.append p.reverse).IsPath
⊢ q.reverse.IsPath
state_after: no goals
tactic: apply h.of_append_left
Theorem: Finset.image₂_left_identity
File: Mathlib/Data/Finset/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f✝ f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t✝ t' : Finset β
u u' : Finset γ
a✝ a' : α
b b' : β
c : γ
f : α → γ → γ
a : α
h : ∀ (b : γ), f a b = b
t : Finset γ
⊢ ↑(image₂ f {a} t) = ↑t
state_after: no goals
tactic: rw [coe_image₂, coe_singleton, Set.image2_left_identity h]