ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: DedekindDomain.ProdAdicCompletions.IsFiniteAdele.mul
File: Mathlib/RingTheory/DedekindDomain/FiniteAdeleRing.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x y : K_hat R K
hx : x.IsFiniteAdele
hy : y.IsFiniteAdele
⊢ (x * y).IsFiniteAdele
state_after: R : Type u_1
K : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x y : K_hat R K
hx : {x_1 | x x_1 ∉ adicCompletionIntegers K x_1}.Finite
hy : {x | y x ∉ adicCompletionIntegers K x}.Finite
⊢ {x_1 | (x * y) x_1 ∉ adicCompletionIntegers K x_1}.Finite
tactic: rw [IsFiniteAdele, Filter.eventually_cofinite] at hx hy ⊢
state_before: R : Type u_1
K : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x y : K_hat R K
hx : {x_1 | x x_1 ∉ adicCompletionIntegers K x_1}.Finite
hy : {x | y x ∉ adicCompletionIntegers K x}.Finite
⊢ {x_1 | (x * y) x_1 ∉ adicCompletionIntegers K x_1}.Finite
state_after: R : Type u_1
K : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x y : K_hat R K
hx : {x_1 | x x_1 ∉ adicCompletionIntegers K x_1}.Finite
hy : {x | y x ∉ adicCompletionIntegers K x}.Finite
h_subset :
  {v | (x * y) v ∉ adicCompletionIntegers K v} ⊆
    {v | x v ∉ adicCompletionIntegers K v} ∪ {v | y v ∉ adicCompletionIntegers K v}
⊢ {x_1 | (x * y) x_1 ∉ adicCompletionIntegers K x_1}.Finite
tactic: have h_subset :
    {v : HeightOneSpectrum R | ¬(x * y) v ∈ v.adicCompletionIntegers K} ⊆
      {v : HeightOneSpectrum R | ¬x v ∈ v.adicCompletionIntegers K} ∪
        {v : HeightOneSpectrum R | ¬y v ∈ v.adicCompletionIntegers K} := by
    intro v hv
    rw [mem_union, mem_setOf, mem_setOf]
    rw [mem_setOf] at hv
    contrapose! hv
    rw [mem_adicCompletionIntegers, mem_adicCompletionIntegers] at hv
    have h_mul : Valued.v (x v * y v) = Valued.v (x v) * Valued.v (y v) :=
      Valued.v.map_mul' (x v) (y v)
    rw [mem_adicCompletionIntegers, Pi.mul_apply, h_mul]
    exact mul_le_one' hv.left hv.right
state_before: R : Type u_1
K : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x y : K_hat R K
hx : {x_1 | x x_1 ∉ adicCompletionIntegers K x_1}.Finite
hy : {x | y x ∉ adicCompletionIntegers K x}.Finite
h_subset :
  {v | (x * y) v ∉ adicCompletionIntegers K v} ⊆
    {v | x v ∉ adicCompletionIntegers K v} ∪ {v | y v ∉ adicCompletionIntegers K v}
⊢ {x_1 | (x * y) x_1 ∉ adicCompletionIntegers K x_1}.Finite
state_after: no goals
tactic: exact (hx.union hy).subset h_subset
Theorem: HomologicalComplex.d_toCycles
File: Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L M : HomologicalComplex C c
φ : K ⟶ L
ψ : L ⟶ M
i j k : ι
inst✝¹ : K.HasHomology i
inst✝ : K.HasHomology k
⊢ K.d i j ≫ K.toCycles j k = 0
state_after: no goals
tactic: simp only [← cancel_mono (K.iCycles k), assoc, toCycles_i, d_comp_d, zero_comp]
Theorem: Finset.esymm_map_val
File: Mathlib/RingTheory/MvPolynomial/Symmetric.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommSemiring R
σ : Type u_2
f : σ → R
s : Finset σ
n : ℕ
⊢ (map f s.val).esymm n = ∑ t ∈ Finset.powersetCard n s, t.prod f
state_after: R : Type u_1
inst✝ : CommSemiring R
σ : Type u_2
f : σ → R
s : Finset σ
n : ℕ
⊢ (map ((fun x => x.prod) ∘ (fun x => map f x) ∘ Finset.val) (Finset.powersetCard n s).val).sum =
    ∑ t ∈ Finset.powersetCard n s, t.prod f
tactic: simp only [esymm, powersetCard_map, ← Finset.map_val_val_powersetCard, map_map]
state_before: R : Type u_1
inst✝ : CommSemiring R
σ : Type u_2
f : σ → R
s : Finset σ
n : ℕ
⊢ (map ((fun x => x.prod) ∘ (fun x => map f x) ∘ Finset.val) (Finset.powersetCard n s).val).sum =
    ∑ t ∈ Finset.powersetCard n s, t.prod f
state_after: no goals
tactic: rfl
Theorem: gc_exterior_interior
File: Mathlib/Topology/AlexandrovDiscrete.lean

Proof steps:
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s✝ t✝ : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
s t : Set α
⊢ exterior s ≤ t ↔ s ≤ interior t
state_after: no goals
tactic: simp [exterior_subset_iff, subset_interior_iff]
Theorem: Localization.mulEquivOfQuotient_monoidOf
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x : M
⊢ (mulEquivOfQuotient f) ((monoidOf S).toMap x) = f.toMap x
state_after: no goals
tactic: simp
Theorem: forall_imp_iff_exists_imp
File: Mathlib/Logic/Basic.lean

Proof steps:
state_before: α✝ : Sort u_1
β : Sort u_2
p✝ q : α✝ → Prop
α : Sort u_3
p : α → Prop
b : Prop
ha : Nonempty α
⊢ (∀ (x : α), p x) → b ↔ ∃ x, p x → b
state_after: α✝ : Sort u_1
β : Sort u_2
p✝ q : α✝ → Prop
α : Sort u_3
p : α → Prop
b : Prop
ha : Nonempty α
a : α
⊢ (∀ (x : α), p x) → b ↔ ∃ x, p x → b
tactic: let ⟨a⟩ := ha
state_before: α✝ : Sort u_1
β : Sort u_2
p✝ q : α✝ → Prop
α : Sort u_3
p : α → Prop
b : Prop
ha : Nonempty α
a : α
⊢ (∀ (x : α), p x) → b ↔ ∃ x, p x → b
state_after: α✝ : Sort u_1
β : Sort u_2
p✝ q : α✝ → Prop
α : Sort u_3
p : α → Prop
b : Prop
ha : Nonempty α
a : α
h : (∀ (x : α), p x) → b
h' : ∀ (x : α), ¬(p x → b)
⊢ False
tactic: refine ⟨fun h ↦ not_forall_not.1 fun h' ↦ ?_, fun ⟨x, hx⟩ h ↦ hx (h x)⟩
state_before: α✝ : Sort u_1
β : Sort u_2
p✝ q : α✝ → Prop
α : Sort u_3
p : α → Prop
b : Prop
ha : Nonempty α
a : α
h : (∀ (x : α), p x) → b
h' : ∀ (x : α), ¬(p x → b)
⊢ False
state_after: no goals
tactic: exact if hb : b then h' a fun _ ↦ hb else hb <| h fun x ↦ (_root_.not_imp.1 (h' x)).1
Theorem: TensorProduct.finsuppScalarRight_apply
File: Mathlib/LinearAlgebra/DirectSum/Finsupp.lean

Proof steps:
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
M : Type u_2
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R N
ι : Type u_4
inst✝⁴ : DecidableEq ι
S : Type u_5
inst✝³ : CommSemiring S
inst✝² : Algebra R S
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
t : M ⊗[R] (ι →₀ R)
i : ι
⊢ ((finsuppScalarRight R M ι) t) i = (TensorProduct.rid R M) ((lTensor M (Finsupp.lapply i)) t)
state_after: no goals
tactic: simp [finsuppScalarRight, finsuppRight_apply]
Theorem: CategoryTheory.Idempotents.Karoubi.decompId_p_toKaroubi
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : C
⊢ ((toKaroubi C).obj X).decompId_p = 𝟙 { X := ((toKaroubi C).obj X).X, p := 𝟙 ((toKaroubi C).obj X).X, idem := ⋯ }
state_after: no goals
tactic: rfl
Theorem: WeierstrassCurve.Affine.CoordinateRing.mk_Ψ_sq
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
n : ℤ
⊢ (mk W) (W.Ψ n) ^ 2 = (mk W) (C (W.ΨSq n))
state_after: no goals
tactic: simp only [Ψ, ΨSq, map_one, map_mul, map_pow, one_pow, mul_pow, ite_pow, apply_ite C,
    apply_ite <| mk W, mk_ψ₂_sq]
Theorem: Mathlib.Vector.mapAccumr_mapAccumr₂
File: Mathlib/Data/Vector/MapLemmas.lean

Proof steps:
state_before: α : Type
n : ℕ
β : Type
xs : Vector α n
ys : Vector β n
γ σ₁ ζ σ₂ : Type
s₂ : σ₂
s₁ : σ₁
f₁ : γ → σ₁ → σ₁ × ζ
f₂ : α → β → σ₂ → σ₂ × γ
⊢ mapAccumr f₁ (mapAccumr₂ f₂ xs ys s₂).2 s₁ =
    let m :=
      mapAccumr₂
        (fun x y s =>
          let r₂ := f₂ x y s.2;
          let r₁ := f₁ r₂.2 s.1;
          ((r₁.1, r₂.1), r₁.2))
        xs ys (s₁, s₂);
    (m.1.1, m.2)
state_after: no goals
tactic: induction xs, ys using Vector.revInductionOn₂ generalizing s₁ s₂ <;> simp_all
Theorem: LinearMap.splittingOfFunOnFintypeSurjective_splits
File: Mathlib/LinearAlgebra/Finsupp.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
α : Type u_4
inst✝ : Finite α
f : M →ₗ[R] α → R
s : Surjective ⇑f
⊢ f ∘ₗ f.splittingOfFunOnFintypeSurjective s = id
state_after: no goals
tactic: classical
  -- Porting note: `ext` can't find appropriate theorems.
  refine pi_ext' fun x => ext_ring <| funext fun y => ?_
  dsimp [splittingOfFunOnFintypeSurjective]
  rw [linearEquivFunOnFinite_symm_single, Finsupp.sum_single_index, one_smul,
    (s (Finsupp.single x 1)).choose_spec, Finsupp.single_eq_pi_single]
  rw [zero_smul]
Theorem: AdjoinRoot.algHom_subsingleton
File: Mathlib/RingTheory/AdjoinRoot.lean

Proof steps:
state_before: R : Type u
S✝ : Type v
K : Type w
inst✝⁴ : CommRing R
f✝ : R[X]
inst✝³ : CommRing S✝
i : R →+* S✝
a : S✝
h : eval₂ i a f✝ = 0
inst✝² : Algebra R S✝
hfx : (aeval a) f✝ = 0
S : Type u_1
inst✝¹ : CommRing S
inst✝ : Algebra R S
r : R
f g : AdjoinRoot (C r * X - 1) →ₐ[R] S
⊢ (algebraMap R S) r * f (root (C r * X - 1)) = 1
state_after: no goals
tactic: rw [← f.commutes, ← _root_.map_mul, algebraMap_eq, root_isInv, map_one]
state_before: R : Type u
S✝ : Type v
K : Type w
inst✝⁴ : CommRing R
f✝ : R[X]
inst✝³ : CommRing S✝
i : R →+* S✝
a : S✝
h : eval₂ i a f✝ = 0
inst✝² : Algebra R S✝
hfx : (aeval a) f✝ = 0
S : Type u_1
inst✝¹ : CommRing S
inst✝ : Algebra R S
r : R
f g : AdjoinRoot (C r * X - 1) →ₐ[R] S
⊢ (algebraMap R S) r * g (root (C r * X - 1)) = 1
state_after: no goals
tactic: rw [← g.commutes, ← _root_.map_mul, algebraMap_eq, root_isInv, map_one]
Theorem: WittVector.fromPadicInt_comp_toPadicInt_ext
File: Mathlib/RingTheory/WittVector/Compare.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : 𝕎 (ZMod p)
⊢ ((fromPadicInt p).comp (toPadicInt p)) x = (RingHom.id (𝕎 (ZMod p))) x
state_after: no goals
tactic: rw [fromPadicInt_comp_toPadicInt]
Theorem: Function.Surjective.preimage_subset_preimage_iff
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
s t : Set β
hf : Surjective f
⊢ f ⁻¹' s ⊆ f ⁻¹' t ↔ s ⊆ t
state_after: case hs
α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
s t : Set β
hf : Surjective f
⊢ s ⊆ range f
tactic: apply Set.preimage_subset_preimage_iff
state_before: case hs
α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
s t : Set β
hf : Surjective f
⊢ s ⊆ range f
state_after: case hs
α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
s t : Set β
hf : Surjective f
⊢ s ⊆ univ
tactic: rw [hf.range_eq]
state_before: case hs
α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
s t : Set β
hf : Surjective f
⊢ s ⊆ univ
state_after: no goals
tactic: apply subset_univ
Theorem: AddSubmonoid.LocalizationMap.neg_unique
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : M →* N
h : ∀ (y : ↥S), IsUnit (f ↑y)
y : ↥S
z : N
H : f ↑y * z = 1
⊢ ↑((IsUnit.liftRight (f.restrict S) h) y)⁻¹ = z
state_after: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : M →* N
h : ∀ (y : ↥S), IsUnit (f ↑y)
y : ↥S
z : N
H : f ↑y * z = 1
⊢ ↑1 = f ↑y * z
tactic: rw [← one_mul _⁻¹, Units.val_mul, mul_inv_left]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : M →* N
h : ∀ (y : ↥S), IsUnit (f ↑y)
y : ↥S
z : N
H : f ↑y * z = 1
⊢ ↑1 = f ↑y * z
state_after: no goals
tactic: exact H.symm
Theorem: Bool.and_le_right
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: ⊢ ∀ (x y : Bool), (x && y) ≤ y
state_after: no goals
tactic: decide
Theorem: WittVector.ghostComponent_frobeniusFun
File: Mathlib/RingTheory/WittVector/Frobenius.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
x : 𝕎 R
⊢ (ghostComponent n) x.frobeniusFun = (ghostComponent (n + 1)) x
state_after: no goals
tactic: simp only [ghostComponent_apply, frobeniusFun, coeff_mk, ← bind₁_frobeniusPoly_wittPolynomial,
    aeval_bind₁]
Theorem: SzemerediRegularity.initialBound_le_bound
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
l : ℕ
⊢ 0 < 16 ^ stepBound^[⌊4 / ε ^ 5⌋₊] (initialBound ε l)
state_after: no goals
tactic: positivity
Theorem: Directed.inf_iSup_eq
File: Mathlib/Order/CompactlyGenerated/Basic.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b : α
s : Set α
h : Directed (fun x x_1 => x ≤ x_1) f
⊢ a ⊓ ⨆ i, f i = ⨆ i, a ⊓ f i
state_after: no goals
tactic: rw [iSup, h.directedOn_range.inf_sSup_eq, iSup_range]
Theorem: Primrec.of_equiv_symm_iff
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β✝
inst✝ : Primcodable σ
β : Type u_4
e : β ≃ α
f : σ → α
this : Primcodable β := Primcodable.ofEquiv α e
h : Primrec fun a => e.symm (f a)
a : σ
⊢ e (e.symm (f a)) = f a
state_after: no goals
tactic: simp
Theorem: FormalMultilinearSeries.coeff_eq_zero
File: Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean

Proof steps:
state_before: 𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p : FormalMultilinearSeries 𝕜 𝕜 E
f : 𝕜 → E
n : ℕ
z z₀ : 𝕜
y : Fin n → 𝕜
⊢ p.coeff n = 0 ↔ p n = 0
state_after: no goals
tactic: rw [← mkPiRing_coeff_eq p, ContinuousMultilinearMap.mkPiRing_eq_zero_iff]
Theorem: isProperMap_iff_isClosedMap_and_compact_fibers
File: Mathlib/Topology/Maps/Proper/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
W : Type u_4
ι : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace W
f : X → Y
g : Y → Z
⊢ IsProperMap f ↔ Continuous f ∧ IsClosedMap f ∧ ∀ (y : Y), IsCompact (f ⁻¹' {y})
state_after: case mp
X : Type u_1
Y : Type u_2
Z : Type u_3
W : Type u_4
ι : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace W
f : X → Y
g : Y → Z
H : IsProperMap f
⊢ Continuous f ∧ IsClosedMap f ∧ ∀ (y : Y), IsCompact (f ⁻¹' {y})

case mpr
X : Type u_1
Y : Type u_2
Z : Type u_3
W : Type u_4
ι : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace W
f : X → Y
g : Y → Z
H : Continuous f ∧ IsClosedMap f ∧ ∀ (y : Y), IsCompact (f ⁻¹' {y})
⊢ IsProperMap f
tactic: constructor <;> intro H
Theorem: sameRay_of_mem_orbit
File: Mathlib/LinearAlgebra/Ray.lean

Proof steps:
state_before: R : Type u_1
inst✝² : LinearOrderedCommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
v₁ v₂ : M
h : v₁ ∈ MulAction.orbit (↥(Units.posSubgroup R)) v₂
⊢ SameRay R v₁ v₂
state_after: case intro.mk
R : Type u_1
inst✝² : LinearOrderedCommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
v₂ : M
r : Rˣ
hr : 0 < ↑r
⊢ SameRay R (r • v₂) v₂
tactic: rcases h with ⟨⟨r, hr : 0 < r.1⟩, rfl : r • v₂ = v₁⟩
state_before: case intro.mk
R : Type u_1
inst✝² : LinearOrderedCommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
v₂ : M
r : Rˣ
hr : 0 < ↑r
⊢ SameRay R (r • v₂) v₂
state_after: no goals
tactic: exact SameRay.sameRay_pos_smul_left _ hr
Theorem: List.cyclicPermutations_injective
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l✝ l'✝ l l' : List α
h : l.cyclicPermutations = l'.cyclicPermutations
⊢ l = l'
state_after: no goals
tactic: simpa using congr_arg head? h
Theorem: Part.toOption_eq_none
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
inst✝ : Decidable o.Dom
⊢ o.toOption = none ↔ ¬o.Dom
state_after: no goals
tactic: by_cases h : o.Dom <;> simp [h, toOption]
Theorem: SimpleGraph.comap_monotone
File: Mathlib/Combinatorics/SimpleGraph/Maps.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v : V
f : V ↪ W
⊢ Monotone (SimpleGraph.comap ⇑f)
state_after: V : Type u_1
W : Type u_2
X : Type u_3
G✝ : SimpleGraph V
G'✝ : SimpleGraph W
u v : V
f : V ↪ W
G G' : SimpleGraph W
h : G ≤ G'
v✝ w✝ : V
ha : (SimpleGraph.comap (⇑f) G).Adj v✝ w✝
⊢ (SimpleGraph.comap (⇑f) G').Adj v✝ w✝
tactic: intro G G' h _ _ ha
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G✝ : SimpleGraph V
G'✝ : SimpleGraph W
u v : V
f : V ↪ W
G G' : SimpleGraph W
h : G ≤ G'
v✝ w✝ : V
ha : (SimpleGraph.comap (⇑f) G).Adj v✝ w✝
⊢ (SimpleGraph.comap (⇑f) G').Adj v✝ w✝
state_after: no goals
tactic: exact h ha
Theorem: IsChain.directed
File: Mathlib/Order/Chain.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c✝ c₁ c₂ c₃ s t : Set α
a✝ b✝ x y : α
inst✝ : IsRefl α r
f : β → α
c : Set β
h : IsChain (f ⁻¹'o r) c
x✝¹ x✝ : { a // a ∈ c }
a : β
ha : a ∈ c
b : β
hb : b ∈ c
hab : a = b
⊢ ∃ z, r ((fun x => f ↑x) ⟨a, ha⟩) ((fun x => f ↑x) z) ∧ r ((fun x => f ↑x) ⟨b, hb⟩) ((fun x => f ↑x) z)
state_after: α : Type u_1
β : Type u_2
r : α → α → Prop
c✝ c₁ c₂ c₃ s t : Set α
a✝ b✝ x y : α
inst✝ : IsRefl α r
f : β → α
c : Set β
h : IsChain (f ⁻¹'o r) c
x✝¹ x✝ : { a // a ∈ c }
a : β
ha : a ∈ c
b : β
hb : b ∈ c
hab : a = b
⊢ ∃ a ∈ c, r (f b) (f a)
tactic: simp only [hab, exists_prop, and_self_iff, Subtype.exists]
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c✝ c₁ c₂ c₃ s t : Set α
a✝ b✝ x y : α
inst✝ : IsRefl α r
f : β → α
c : Set β
h : IsChain (f ⁻¹'o r) c
x✝¹ x✝ : { a // a ∈ c }
a : β
ha : a ∈ c
b : β
hb : b ∈ c
hab : a = b
⊢ ∃ a ∈ c, r (f b) (f a)
state_after: no goals
tactic: exact ⟨b, hb, refl _⟩
Theorem: Ideal.mem_span_singleton_mul
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J K L : Ideal R
x y : R
I : Ideal R
⊢ x ∈ span {y} * I ↔ ∃ z ∈ I, y * z = x
state_after: no goals
tactic: simp only [mul_comm, mem_mul_span_singleton]
Theorem: TypeVec.snd_diag
File: Mathlib/Data/TypeVec.lean

Proof steps:
state_before: n : ℕ
α : TypeVec.{u_1} n
⊢ prod.snd ⊚ prod.diag = id
state_after: case h
n : ℕ
α : TypeVec.{u_1} n
i : Fin2 n
⊢ (prod.snd ⊚ prod.diag) i = id i
tactic: funext i
state_before: case h
n : ℕ
α : TypeVec.{u_1} n
i : Fin2 n
⊢ (prod.snd ⊚ prod.diag) i = id i
state_after: no goals
tactic: induction i with
  | fz => rfl
  | fs _ i_ih => apply i_ih
Theorem: Algebra.Generators.Hom.id_val
File: Mathlib/RingTheory/Generators.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝²⁵ : CommRing R
inst✝²⁴ : CommRing S
inst✝²³ : Algebra R S
P : Generators R S
R' : Type ?u.294116
S' : Type ?u.294119
inst✝²² : CommRing R'
inst✝²¹ : CommRing S'
inst✝²⁰ : Algebra R' S'
P' : Generators R' S'
inst✝¹⁹ : Algebra R R'
inst✝¹⁸ : Algebra S S'
inst✝¹⁷ : Algebra R S'
inst✝¹⁶ : IsScalarTower R R' S'
inst✝¹⁵ : IsScalarTower R S S'
R'' : Type ?u.296550
S'' : Type ?u.296553
inst✝¹⁴ : CommRing R''
inst✝¹³ : CommRing S''
inst✝¹² : Algebra R'' S''
P'' : Generators R'' S''
inst✝¹¹ : Algebra R R''
inst✝¹⁰ : Algebra S S''
inst✝⁹ : Algebra R S''
inst✝⁸ : IsScalarTower R R'' S''
inst✝⁷ : IsScalarTower R S S''
inst✝⁶ : Algebra R' R''
inst✝⁵ : Algebra S' S''
inst✝⁴ : Algebra R' S''
inst✝³ : IsScalarTower R' R'' S''
inst✝² : IsScalarTower R' S' S''
inst✝¹ : IsScalarTower R R' R''
inst✝ : IsScalarTower S S' S''
⊢ ∀ (i : P.vars), (aeval P.val) (X i) = (algebraMap S S) (P.val i)
state_after: no goals
tactic: simp
Theorem: Inducing.secondCountableTopology
File: Mathlib/Topology/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
f : α → β
inst✝ : SecondCountableTopology β
hf : Inducing f
⊢ SecondCountableTopology α
state_after: no goals
tactic: exact secondCountableTopology_induced α β f
Theorem: CliffordAlgebra.involute_prod_map_ι
File: Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
⊢ involute (List.map ⇑(ι Q) []).prod = (-1) ^ [].length • (List.map ⇑(ι Q) []).prod
state_after: no goals
tactic: simp
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x : M
xs : List M
⊢ involute (List.map (⇑(ι Q)) (x :: xs)).prod = (-1) ^ (x :: xs).length • (List.map (⇑(ι Q)) (x :: xs)).prod
state_after: no goals
tactic: simp [pow_succ, involute_prod_map_ι xs]
Theorem: RCLike.toOrderedSMul
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w a b : K
r : ℝ
hab : a < b
hr : 0 < r
⊢ r • a ≤ r • b
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w a b : K
r : ℝ
hr : 0 < r
hab : a ≤ b
⊢ r • a ≤ r • b
tactic: replace hab := hab.le
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w a b : K
r : ℝ
hr : 0 < r
hab : a ≤ b
⊢ r • a ≤ r • b
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w a b : K
r : ℝ
hr : 0 < r
hab : re a ≤ re b ∧ im a = im b
⊢ r • a ≤ r • b
tactic: rw [RCLike.le_iff_re_im] at hab
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w a b : K
r : ℝ
hr : 0 < r
hab : re a ≤ re b ∧ im a = im b
⊢ r • a ≤ r • b
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w a b : K
r : ℝ
hr : 0 < r
hab : re a ≤ re b ∧ im a = im b
⊢ r * re a ≤ r * re b ∧ r * im a = r * im b
tactic: rw [RCLike.le_iff_re_im, smul_re, smul_re, smul_im, smul_im]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w a b : K
r : ℝ
hr : 0 < r
hab : re a ≤ re b ∧ im a = im b
⊢ r * re a ≤ r * re b ∧ r * im a = r * im b
state_after: no goals
tactic: exact hab.imp (fun h => mul_le_mul_of_nonneg_left h hr.le) (congr_arg _)
Theorem: lt_min
File: Mathlib/Init/Order/LinearOrder.lean

Proof steps:
state_before: α : Type u
inst✝ : LinearOrder α
a b c : α
h₁ : a < b
h₂ : a < c
h : b ≤ c
⊢ a < min b c
state_after: no goals
tactic: rwa [min_eq_left h]
state_before: α : Type u
inst✝ : LinearOrder α
a b c : α
h₁ : a < b
h₂ : a < c
h : b > c
⊢ a < min b c
state_after: no goals
tactic: rwa [min_eq_right_of_lt h]
Theorem: AddEquiv.op_apply_apply
File: Mathlib/Algebra/Group/Opposite.lean

Proof steps:
state_before: α✝ : Type u_1
α : Type ?u.39365
β : Type ?u.39368
inst✝¹ : Mul α
inst✝ : Mul β
f : αᵐᵒᵖ ≃* βᵐᵒᵖ
x : α
⊢ (unop ∘ ⇑f.symm ∘ MulOpposite.op) ((unop ∘ ⇑f ∘ MulOpposite.op) x) = x
state_after: no goals
tactic: simp
state_before: α✝ : Type u_1
α : Type ?u.39365
β : Type ?u.39368
inst✝¹ : Mul α
inst✝ : Mul β
f : αᵐᵒᵖ ≃* βᵐᵒᵖ
x : β
⊢ (unop ∘ ⇑f ∘ MulOpposite.op) ((unop ∘ ⇑f.symm ∘ MulOpposite.op) x) = x
state_after: no goals
tactic: simp