ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Polynomial.toSubring_zero
File: Mathlib/RingTheory/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑p.coeffs ⊆ ↑T
⊢ ↑(coeffs 0) ⊆ ↑T
state_after: no goals
tactic: simp [coeffs]
state_before: R : Type u
S : Type u_1
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑p.coeffs ⊆ ↑T
⊢ toSubring 0 T ⋯ = 0
state_after: case a.a
R : Type u
S : Type u_1
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑p.coeffs ⊆ ↑T
i : ℕ
⊢ ↑((toSubring 0 T ⋯).coeff i) = ↑(coeff 0 i)
tactic: ext i
state_before: case a.a
R : Type u
S : Type u_1
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑p.coeffs ⊆ ↑T
i : ℕ
⊢ ↑((toSubring 0 T ⋯).coeff i) = ↑(coeff 0 i)
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.coprod.map_codiag
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ X Y : C
f : X ⟶ Y
inst✝¹ : HasBinaryCoproduct X X
inst✝ : HasBinaryCoproduct Y Y
⊢ map f f ≫ codiag Y = codiag X ≫ f
state_after: no goals
tactic: simp
Theorem: Relation.ReflTransGen.symmetric
File: Mathlib/Logic/Relation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : Symmetric r
⊢ Symmetric (ReflTransGen r)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h✝ : Symmetric r
x y : α
h : ReflTransGen r x y
⊢ ReflTransGen r y x
tactic: intro x y h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h✝ : Symmetric r
x y : α
h : ReflTransGen r x y
⊢ ReflTransGen r y x
state_after: case refl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : Symmetric r
x y : α
⊢ ReflTransGen r x x

case tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b✝ c✝ d : α
h : Symmetric r
x y z w : α
a✝ : ReflTransGen r x z
b : r z w
c : ReflTransGen r z x
⊢ ReflTransGen r w x
tactic: induction' h with z w _ b c
Theorem: TensorProduct.directSum_lof_tmul_lof
File: Mathlib/LinearAlgebra/DirectSum/TensorProduct.lean

Proof steps:
state_before: R : Type u
inst✝¹⁴ : CommSemiring R
S : Type u_1
inst✝¹³ : Semiring S
inst✝¹² : Algebra R S
ι₁ : Type v₁
ι₂ : Type v₂
inst✝¹¹ : DecidableEq ι₁
inst✝¹⁰ : DecidableEq ι₂
M₁ : ι₁ → Type w₁
M₁' : Type w₁'
M₂ : ι₂ → Type w₂
M₂' : Type w₂'
inst✝⁹ : (i₁ : ι₁) → AddCommMonoid (M₁ i₁)
inst✝⁸ : AddCommMonoid M₁'
inst✝⁷ : (i₂ : ι₂) → AddCommMonoid (M₂ i₂)
inst✝⁶ : AddCommMonoid M₂'
inst✝⁵ : (i₁ : ι₁) → Module R (M₁ i₁)
inst✝⁴ : Module R M₁'
inst✝³ : (i₂ : ι₂) → Module R (M₂ i₂)
inst✝² : Module R M₂'
inst✝¹ : (i₁ : ι₁) → Module S (M₁ i₁)
inst✝ : ∀ (i₁ : ι₁), IsScalarTower R S (M₁ i₁)
i₁ : ι₁
m₁ : M₁ i₁
i₂ : ι₂
m₂ : M₂ i₂
⊢ (TensorProduct.directSum R S M₁ M₂) ((lof S ι₁ M₁ i₁) m₁ ⊗ₜ[R] (lof R ι₂ M₂ i₂) m₂) =
    (lof S (ι₁ × ι₂) (fun i => M₁ i.1 ⊗[R] M₂ i.2) (i₁, i₂)) (m₁ ⊗ₜ[R] m₂)
state_after: no goals
tactic: simp [TensorProduct.directSum]
Theorem: eventually_nhdsWithin_nhdsWithin
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
a : α
s : Set α
p : α → Prop
⊢ (∀ᶠ (y : α) in 𝓝[s] a, ∀ᶠ (x : α) in 𝓝[s] y, p x) ↔ ∀ᶠ (x : α) in 𝓝[s] a, p x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
a : α
s : Set α
p : α → Prop
h : ∀ᶠ (y : α) in 𝓝[s] a, ∀ᶠ (x : α) in 𝓝[s] y, p x
⊢ ∀ᶠ (x : α) in 𝓝[s] a, p x
tactic: refine ⟨fun h => ?_, fun h => (eventually_nhds_nhdsWithin.2 h).filter_mono inf_le_left⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
a : α
s : Set α
p : α → Prop
h : ∀ᶠ (y : α) in 𝓝[s] a, ∀ᶠ (x : α) in 𝓝[s] y, p x
⊢ ∀ᶠ (x : α) in 𝓝[s] a, p x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
a : α
s : Set α
p : α → Prop
h : ∀ᶠ (x : α) in 𝓝 a, x ∈ s → ∀ᶠ (x : α) in 𝓝 x, x ∈ s → p x
⊢ ∀ᶠ (x : α) in 𝓝 a, x ∈ s → p x
tactic: simp only [eventually_nhdsWithin_iff] at h ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
a : α
s : Set α
p : α → Prop
h : ∀ᶠ (x : α) in 𝓝 a, x ∈ s → ∀ᶠ (x : α) in 𝓝 x, x ∈ s → p x
⊢ ∀ᶠ (x : α) in 𝓝 a, x ∈ s → p x
state_after: no goals
tactic: exact h.mono fun x hx hxs => (hx hxs).self_of_nhds hxs
Theorem: Relation.cutExpand_singleton_singleton
File: Mathlib/Logic/Hydra.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
x' x : α
h✝ : r x' x
a : α
h : a ∈ {x'}
⊢ r a x
state_after: no goals
tactic: rwa [mem_singleton.1 h]
Theorem: CliffordAlgebra.ι_mul_ι_mem_evenOdd_zero
File: Mathlib/LinearAlgebra/CliffordAlgebra/Grading.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m₁ m₂ : M
⊢ (ι Q) m₁ * (ι Q) m₂ ∈ LinearMap.range (ι Q) ^ ↑⟨2, ⋯⟩
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m₁ m₂ : M
⊢ (ι Q) m₁ * (ι Q) m₂ ∈ LinearMap.range (ι Q) * LinearMap.range (ι Q)
tactic: rw [Subtype.coe_mk, pow_two]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m₁ m₂ : M
⊢ (ι Q) m₁ * (ι Q) m₂ ∈ LinearMap.range (ι Q) * LinearMap.range (ι Q)
state_after: no goals
tactic: exact
        Submodule.mul_mem_mul (LinearMap.mem_range_self (ι Q) m₁)
          (LinearMap.mem_range_self (ι Q) m₂)
Theorem: RingHom.ext_zmod
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: n : ℕ
R : Type u_1
inst✝ : Semiring R
f g : ZMod n →+* R
⊢ f = g
state_after: case a
n : ℕ
R : Type u_1
inst✝ : Semiring R
f g : ZMod n →+* R
a : ZMod n
⊢ f a = g a
tactic: ext a
state_before: case a
n : ℕ
R : Type u_1
inst✝ : Semiring R
f g : ZMod n →+* R
a : ZMod n
⊢ f a = g a
state_after: case a.intro
n : ℕ
R : Type u_1
inst✝ : Semiring R
f g : ZMod n →+* R
k : ℤ
⊢ f ↑k = g ↑k
tactic: obtain ⟨k, rfl⟩ := ZMod.intCast_surjective a
state_before: case a.intro
n : ℕ
R : Type u_1
inst✝ : Semiring R
f g : ZMod n →+* R
k : ℤ
⊢ f ↑k = g ↑k
state_after: case a.intro
n : ℕ
R : Type u_1
inst✝ : Semiring R
f g : ZMod n →+* R
k : ℤ
φ : ℤ →+* R := f.comp (Int.castRingHom (ZMod n))
⊢ f ↑k = g ↑k
tactic: let φ : ℤ →+* R := f.comp (Int.castRingHom (ZMod n))
state_before: case a.intro
n : ℕ
R : Type u_1
inst✝ : Semiring R
f g : ZMod n →+* R
k : ℤ
φ : ℤ →+* R := f.comp (Int.castRingHom (ZMod n))
⊢ f ↑k = g ↑k
state_after: case a.intro
n : ℕ
R : Type u_1
inst✝ : Semiring R
f g : ZMod n →+* R
k : ℤ
φ : ℤ →+* R := f.comp (Int.castRingHom (ZMod n))
ψ : ℤ →+* R := g.comp (Int.castRingHom (ZMod n))
⊢ f ↑k = g ↑k
tactic: let ψ : ℤ →+* R := g.comp (Int.castRingHom (ZMod n))
state_before: case a.intro
n : ℕ
R : Type u_1
inst✝ : Semiring R
f g : ZMod n →+* R
k : ℤ
φ : ℤ →+* R := f.comp (Int.castRingHom (ZMod n))
ψ : ℤ →+* R := g.comp (Int.castRingHom (ZMod n))
⊢ f ↑k = g ↑k
state_after: case a.intro
n : ℕ
R : Type u_1
inst✝ : Semiring R
f g : ZMod n →+* R
k : ℤ
φ : ℤ →+* R := f.comp (Int.castRingHom (ZMod n))
ψ : ℤ →+* R := g.comp (Int.castRingHom (ZMod n))
⊢ φ k = ψ k
tactic: show φ k = ψ k
state_before: case a.intro
n : ℕ
R : Type u_1
inst✝ : Semiring R
f g : ZMod n →+* R
k : ℤ
φ : ℤ →+* R := f.comp (Int.castRingHom (ZMod n))
ψ : ℤ →+* R := g.comp (Int.castRingHom (ZMod n))
⊢ φ k = ψ k
state_after: no goals
tactic: rw [φ.ext_int ψ]
Theorem: List.pmap_congr
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p q : α → Prop
f : (a : α) → p a → β
g : (a : α) → q a → β
l : List α
H₁ : ∀ (a : α), a ∈ l → p a
H₂ : ∀ (a : α), a ∈ l → q a
h : ∀ (a : α), a ∈ l → ∀ (h₁ : p a) (h₂ : q a), f a h₁ = g a h₂
⊢ pmap f l H₁ = pmap g l H₂
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p q : α → Prop
f : (a : α) → p a → β
g : (a : α) → q a → β
H₁ : ∀ (a : α), a ∈ [] → p a
H₂ : ∀ (a : α), a ∈ [] → q a
h : ∀ (a : α), a ∈ [] → ∀ (h₁ : p a) (h₂ : q a), f a h₁ = g a h₂
⊢ pmap f [] H₁ = pmap g [] H₂

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p q : α → Prop
f : (a : α) → p a → β
g : (a : α) → q a → β
head✝ : α
tail✝ : List α
ih :
  ∀ {H₁ : ∀ (a : α), a ∈ tail✝ → p a} {H₂ : ∀ (a : α), a ∈ tail✝ → q a},
    (∀ (a : α), a ∈ tail✝ → ∀ (h₁ : p a) (h₂ : q a), f a h₁ = g a h₂) → pmap f tail✝ H₁ = pmap g tail✝ H₂
H₁ : ∀ (a : α), a ∈ head✝ :: tail✝ → p a
H₂ : ∀ (a : α), a ∈ head✝ :: tail✝ → q a
h : ∀ (a : α), a ∈ head✝ :: tail✝ → ∀ (h₁ : p a) (h₂ : q a), f a h₁ = g a h₂
⊢ pmap f (head✝ :: tail✝) H₁ = pmap g (head✝ :: tail✝) H₂
tactic: induction' l with _ _ ih
Theorem: ProbabilityTheory.Kernel.indepSets_singleton_iff
File: Mathlib/Probability/Independence/Kernel.lean

Proof steps:
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
s t : Set Ω
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
h : ∀ᵐ (a : α) ∂μ, (κ a) (s ∩ t) = (κ a) s * (κ a) t
s1 t1 : Set Ω
hs1 : s1 ∈ {s}
ht1 : t1 ∈ {t}
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (s1 ∩ t1) = (κ a) s1 * (κ a) t1
state_after: no goals
tactic: rwa [Set.mem_singleton_iff.mp hs1, Set.mem_singleton_iff.mp ht1]
Theorem: Dense.borel_eq_generateFrom_Ico_mem
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s✝ t u : Set α✝
inst✝¹¹ : TopologicalSpace α✝
inst✝¹⁰ : MeasurableSpace α✝
inst✝⁹ : OpensMeasurableSpace α✝
inst✝⁸ : MeasurableSpace δ
inst✝⁷ : LinearOrder α✝
inst✝⁶ : OrderClosedTopology α✝
a b x : α✝
α : Type u_5
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : OrderTopology α
inst✝² : SecondCountableTopology α
inst✝¹ : DenselyOrdered α
inst✝ : NoMinOrder α
s : Set α
hd : Dense s
⊢ ∀ (x : α), IsBot x → x ∈ s
state_after: no goals
tactic: simp
Theorem: GaussianInt.intCast_real_norm
File: Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean

Proof steps:
state_before: x : ℤ[i]
⊢ ↑(norm x) = normSq (toComplex x)
state_after: x : ℤ[i]
⊢ ↑(x.re * x.re - -1 * x.im * x.im) =
    { toFun := fun z => z.re * z.re + z.im * z.im, map_zero' := normSq.proof_1, map_one' := normSq.proof_2,
        map_mul' := normSq.proof_3 }
      (toComplex x)
tactic: rw [Zsqrtd.norm, normSq]
state_before: x : ℤ[i]
⊢ ↑(x.re * x.re - -1 * x.im * x.im) =
    { toFun := fun z => z.re * z.re + z.im * z.im, map_zero' := normSq.proof_1, map_one' := normSq.proof_2,
        map_mul' := normSq.proof_3 }
      (toComplex x)
state_after: no goals
tactic: simp
Theorem: div_mul_div_cancel'
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b✝ c✝ d : G
n : ℤ
a b c : G
⊢ a / b * (b / c) = a / c
state_after: no goals
tactic: rw [← mul_div_assoc, div_mul_cancel]
Theorem: lt_of_strongLT
File: Mathlib/Order/Basic.lean

Proof steps:
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: 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
inhabited_h : Inhabited ι
⊢ a < b
state_after: no goals
tactic: exact Pi.lt_def.2 ⟨le_of_strongLT h, default, h _⟩
Theorem: Cube.insertAt_boundary
File: Mathlib/Topology/Homotopy/HomotopyGroup.lean

Proof steps:
state_before: N : Type u_1
inst✝ : DecidableEq N
i : N
t₀ : ↑I
t : { j // j ≠ i } → ↑I
H : (t₀ = 0 ∨ t₀ = 1) ∨ t ∈ boundary { j // j ≠ i }
⊢ (insertAt i) (t₀, t) ∈ boundary N
state_after: case inl
N : Type u_1
inst✝ : DecidableEq N
i : N
t₀ : ↑I
t : { j // j ≠ i } → ↑I
H : t₀ = 0 ∨ t₀ = 1
⊢ (insertAt i) (t₀, t) ∈ boundary N

case inr.intro
N : Type u_1
inst✝ : DecidableEq N
i : N
t₀ : ↑I
t : { j // j ≠ i } → ↑I
j : { j // j ≠ i }
H : t j = 0 ∨ t j = 1
⊢ (insertAt i) (t₀, t) ∈ boundary N
tactic: obtain H | ⟨j, H⟩ := H
Theorem: CategoryTheory.Idempotents.isIdempotentComplete_iff_idempotents_have_kernels
File: Mathlib/CategoryTheory/Idempotents/Basic.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
⊢ IsIdempotentComplete C ↔ ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasKernel p
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
⊢ (∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasEqualizer (𝟙 X) p) ↔ ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasKernel p
tactic: rw [isIdempotentComplete_iff_hasEqualizer_of_id_and_idempotent]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
⊢ (∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasEqualizer (𝟙 X) p) ↔ ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasKernel p
state_after: case mp
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
⊢ (∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasEqualizer (𝟙 X) p) → ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasKernel p

case mpr
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
⊢ (∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasKernel p) → ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasEqualizer (𝟙 X) p
tactic: constructor
Theorem: isPiSystem_Ixx
File: Mathlib/MeasureTheory/PiSystem.lean

Proof steps:
state_before: α : Type u_1
ι : Sort u_2
ι' : Sort u_3
inst✝ : LinearOrder α
Ixx : α → α → Set α
p : α → α → Prop
Hne : ∀ {a b : α}, (Ixx a b).Nonempty → p a b
Hi : ∀ {a₁ b₁ a₂ b₂ : α}, Ixx a₁ b₁ ∩ Ixx a₂ b₂ = Ixx (max a₁ a₂) (min b₁ b₂)
f : ι → α
g : ι' → α
⊢ IsPiSystem {S | ∃ i j, p (f i) (g j) ∧ Ixx (f i) (g j) = S}
state_after: no goals
tactic: simpa only [exists_range_iff] using isPiSystem_Ixx_mem (@Hne) (@Hi) (range f) (range g)
Theorem: FirstOrder.Language.Equiv.realize_formula
File: Mathlib/ModelTheory/Semantics.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
g : M ≃[L] N
φ : L.Formula α
v : α → M
⊢ φ.Realize (⇑g ∘ v) ↔ φ.Realize v
state_after: no goals
tactic: rw [Formula.Realize, Formula.Realize, ← g.realize_boundedFormula φ, iff_eq_eq,
    Unique.eq_default (g ∘ default)]
Theorem: ZMod.ringEquivCongr_refl
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : CharP R n
a : ℕ
⊢ ringEquivCongr ⋯ = RingEquiv.refl (ZMod a)
state_after: no goals
tactic: cases a <;> rfl
Theorem: Filter.mem_kernMap_iff_compl
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
m : α → β
f : Filter α
s : Set β
⊢ s ∈ kernMap m f ↔ ∃ t, tᶜ ∈ f ∧ m '' t = sᶜ
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
m : α → β
f : Filter α
s : Set β
⊢ (∃ x, xᶜ ∈ f ∧ kernImage m xᶜ = s) ↔ ∃ t, tᶜ ∈ f ∧ m '' t = sᶜ
tactic: rw [mem_kernMap, compl_surjective.exists]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
m : α → β
f : Filter α
s : Set β
⊢ (∃ x, xᶜ ∈ f ∧ kernImage m xᶜ = s) ↔ ∃ t, tᶜ ∈ f ∧ m '' t = sᶜ
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
m : α → β
f : Filter α
s : Set β
x : Set α
x✝ : xᶜ ∈ f
⊢ kernImage m xᶜ = s ↔ m '' x = sᶜ
tactic: refine exists_congr (fun x ↦ and_congr_right fun _ ↦ ?_)
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
m : α → β
f : Filter α
s : Set β
x : Set α
x✝ : xᶜ ∈ f
⊢ kernImage m xᶜ = s ↔ m '' x = sᶜ
state_after: no goals
tactic: rw [kernImage_compl, compl_eq_comm, eq_comm]
Theorem: ModularGroup.re_T_zpow_smul
File: Mathlib/NumberTheory/Modular.lean

Proof steps:
state_before: g : SL(2, ℤ)
z : ℍ
n : ℤ
⊢ (T ^ n • z).re = z.re + ↑n
state_after: no goals
tactic: rw [← coe_re, coe_T_zpow_smul_eq, add_re, intCast_re, coe_re]
Theorem: CategoryTheory.CosimplicialObject.Augmented.leftOpRightOpIso_inv_left
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : Augmented Cᵒᵖ
⊢ X.leftOp.rightOp.left = X.left
state_after: no goals
tactic: simp
Theorem: MeasureTheory.Integrable.sup
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_5
inst✝ : NormedLatticeAddCommGroup β
f g : α → β
hf : Integrable f μ
hg : Integrable g μ
⊢ Integrable (f ⊔ g) μ
state_after: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_5
inst✝ : NormedLatticeAddCommGroup β
f g : α → β
hf : Memℒp f 1 μ
hg : Memℒp g 1 μ
⊢ Memℒp (f ⊔ g) 1 μ
tactic: rw [← memℒp_one_iff_integrable] at hf hg ⊢
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_5
inst✝ : NormedLatticeAddCommGroup β
f g : α → β
hf : Memℒp f 1 μ
hg : Memℒp g 1 μ
⊢ Memℒp (f ⊔ g) 1 μ
state_after: no goals
tactic: exact hf.sup hg
Theorem: Complex.eqOn_closure_of_eqOn_frontier
File: Mathlib/Analysis/Complex/AbsMax.lean

Proof steps:
state_before: E : Type u
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℂ E
F : Type v
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℂ F
inst✝ : Nontrivial E
f g : E → F
U : Set E
hU : Bornology.IsBounded U
hf : DiffContOnCl ℂ f U
hg : DiffContOnCl ℂ g U
hfg : EqOn f g (frontier U)
⊢ EqOn f g (closure U)
state_after: E : Type u
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℂ E
F : Type v
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℂ F
inst✝ : Nontrivial E
f g : E → F
U : Set E
hU : Bornology.IsBounded U
hf : DiffContOnCl ℂ f U
hg : DiffContOnCl ℂ g U
hfg : EqOn f g (frontier U)
⊢ ∀ z ∈ closure U, ‖(f - g) z‖ ≤ 0
tactic: suffices H : ∀ z ∈ closure U, ‖(f - g) z‖ ≤ 0 by simpa [sub_eq_zero] using H
state_before: E : Type u
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℂ E
F : Type v
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℂ F
inst✝ : Nontrivial E
f g : E → F
U : Set E
hU : Bornology.IsBounded U
hf : DiffContOnCl ℂ f U
hg : DiffContOnCl ℂ g U
hfg : EqOn f g (frontier U)
⊢ ∀ z ∈ closure U, ‖(f - g) z‖ ≤ 0
state_after: E : Type u
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℂ E
F : Type v
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℂ F
inst✝ : Nontrivial E
f g : E → F
U : Set E
hU : Bornology.IsBounded U
hf : DiffContOnCl ℂ f U
hg : DiffContOnCl ℂ g U
hfg : EqOn f g (frontier U)
z : E
hz : z ∈ closure U
w : E
hw : w ∈ frontier U
⊢ ‖(f - g) w‖ ≤ 0
tactic: refine fun z hz => norm_le_of_forall_mem_frontier_norm_le hU (hf.sub hg) (fun w hw => ?_) hz
state_before: E : Type u
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℂ E
F : Type v
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℂ F
inst✝ : Nontrivial E
f g : E → F
U : Set E
hU : Bornology.IsBounded U
hf : DiffContOnCl ℂ f U
hg : DiffContOnCl ℂ g U
hfg : EqOn f g (frontier U)
z : E
hz : z ∈ closure U
w : E
hw : w ∈ frontier U
⊢ ‖(f - g) w‖ ≤ 0
state_after: no goals
tactic: simp [hfg hw]
Theorem: OpenEmbedding.compatiblePreserving
File: Mathlib/Topology/Sheaves/SheafCondition/Sites.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
⊢ CompatiblePreserving (Opens.grothendieckTopology ↑Y) ⋯.functor
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
⊢ CompatiblePreserving (Opens.grothendieckTopology ↑Y) ⋯.functor
tactic: haveI : Mono f := (TopCat.mono_iff_injective f).mpr hf.inj
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
⊢ CompatiblePreserving (Opens.grothendieckTopology ↑Y) ⋯.functor
state_after: case hF
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
⊢ {c : Opens ↑X} → {d : Opens ↑Y} → (d ⟶ ⋯.functor.obj c) → (c' : Opens ↑X) × (⋯.functor.obj c' ≅ d)
tactic: apply compatiblePreservingOfDownwardsClosed
state_before: case hF
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
⊢ {c : Opens ↑X} → {d : Opens ↑Y} → (d ⟶ ⋯.functor.obj c) → (c' : Opens ↑X) × (⋯.functor.obj c' ≅ d)
state_after: case hF
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
U : Opens ↑X
V : Opens ↑Y
i : V ⟶ ⋯.functor.obj U
⊢ (c' : Opens ↑X) × (⋯.functor.obj c' ≅ V)
tactic: intro U V i
state_before: case hF
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
U : Opens ↑X
V : Opens ↑Y
i : V ⟶ ⋯.functor.obj U
⊢ (c' : Opens ↑X) × (⋯.functor.obj c' ≅ V)
state_after: case hF
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
U : Opens ↑X
V : Opens ↑Y
i : V ⟶ ⋯.functor.obj U
x : ↑Y
h : x ∈ V.1
⊢ x ∈ Set.range ⇑f
tactic: refine ⟨(Opens.map f).obj V, eqToIso <| Opens.ext <| Set.image_preimage_eq_of_subset fun x h ↦ ?_⟩
state_before: case hF
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
U : Opens ↑X
V : Opens ↑Y
i : V ⟶ ⋯.functor.obj U
x : ↑Y
h : x ∈ V.1
⊢ x ∈ Set.range ⇑f
state_after: case hF.intro.intro
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
U : Opens ↑X
V : Opens ↑Y
i : V ⟶ ⋯.functor.obj U
w✝ : ↑X
left✝ : w✝ ∈ ↑U
h : f w✝ ∈ V.1
⊢ f w✝ ∈ Set.range ⇑f
tactic: obtain ⟨_, _, rfl⟩ := i.le h
state_before: case hF.intro.intro
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
U : Opens ↑X
V : Opens ↑Y
i : V ⟶ ⋯.functor.obj U
w✝ : ↑X
left✝ : w✝ ∈ ↑U
h : f w✝ ∈ V.1
⊢ f w✝ ∈ Set.range ⇑f
state_after: no goals
tactic: exact ⟨_, rfl⟩
Theorem: PartialHomeomorph.ofSet_trans'
File: Mathlib/Topology/PartialHomeomorph.lean

Proof steps:
state_before: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e : PartialHomeomorph X Y
e' : PartialHomeomorph Y Z
s : Set X
hs : IsOpen s
⊢ (ofSet s hs).trans e = e.restr (e.source ∩ s)
state_after: no goals
tactic: rw [ofSet_trans, restr_source_inter]
Theorem: Disjoint.symmDiff_left
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
ha : Disjoint a c
hb : Disjoint b c
⊢ Disjoint (a ∆ b) c
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
ha : Disjoint a c
hb : Disjoint b c
⊢ Disjoint ((a ⊔ b) \ (a ⊓ b)) c
tactic: rw [symmDiff_eq_sup_sdiff_inf]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
ha : Disjoint a c
hb : Disjoint b c
⊢ Disjoint ((a ⊔ b) \ (a ⊓ b)) c
state_after: no goals
tactic: exact (ha.sup_left hb).disjoint_sdiff_left