ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Filter.HasBasis.inf'
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : l.HasBasis p s
hl' : l'.HasBasis p' s'
⊢ ∀ (t : Set α), t ∈ l ⊓ l' ↔ ∃ i, (p i.fst ∧ p' i.snd) ∧ s i.fst ∩ s' i.snd ⊆ t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : l.HasBasis p s
hl' : l'.HasBasis p' s'
t : Set α
⊢ t ∈ l ⊓ l' ↔ ∃ i, (p i.fst ∧ p' i.snd) ∧ s i.fst ∩ s' i.snd ⊆ t
tactic: intro t
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : l.HasBasis p s
hl' : l'.HasBasis p' s'
t : Set α
⊢ t ∈ l ⊓ l' ↔ ∃ i, (p i.fst ∧ p' i.snd) ∧ s i.fst ∩ s' i.snd ⊆ t
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : l.HasBasis p s
hl' : l'.HasBasis p' s'
t : Set α
⊢ t ∈ l ⊓ l' → ∃ i, (p i.fst ∧ p' i.snd) ∧ s i.fst ∩ s' i.snd ⊆ t

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : l.HasBasis p s
hl' : l'.HasBasis p' s'
t : Set α
⊢ (∃ i, (p i.fst ∧ p' i.snd) ∧ s i.fst ∩ s' i.snd ⊆ t) → t ∈ l ⊓ l'
tactic: constructor
Theorem: Matrix.conjTranspose_mul_self_mulVec_eq_zero
File: Mathlib/LinearAlgebra/Matrix/DotProduct.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : Fintype p
inst✝⁴ : PartialOrder R
inst✝³ : NonUnitalRing R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : NoZeroDivisors R
A : Matrix m n R
v : n → R
⊢ (Aᴴ * A) *ᵥ v = 0 ↔ A *ᵥ v = 0
state_after: no goals
tactic: simpa only [← Matrix.col_mulVec, col_eq_zero] using
    conjTranspose_mul_self_mul_eq_zero A (col (Fin 1) v)
Theorem: AList.perm_insert
File: Mathlib/Data/List/AList.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s₁ s₂ : AList β
p : s₁.entries ~ s₂.entries
⊢ (insert a b s₁).entries ~ (insert a b s₂).entries
state_after: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s₁ s₂ : AList β
p : s₁.entries ~ s₂.entries
⊢ ⟨a, b⟩ :: kerase a s₁.entries ~ ⟨a, b⟩ :: kerase a s₂.entries
tactic: simp only [insert_entries]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s₁ s₂ : AList β
p : s₁.entries ~ s₂.entries
⊢ ⟨a, b⟩ :: kerase a s₁.entries ~ ⟨a, b⟩ :: kerase a s₂.entries
state_after: no goals
tactic: exact p.kinsert s₁.nodupKeys
Theorem: coe_upperClosure
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s✝ t : Set α
x : α
s : Set α
⊢ ↑(upperClosure s) = ⋃ a ∈ s, Ici a
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s✝ t : Set α
x : α
s : Set α
x✝ : α
⊢ x✝ ∈ ↑(upperClosure s) ↔ x✝ ∈ ⋃ a ∈ s, Ici a
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s✝ t : Set α
x : α
s : Set α
x✝ : α
⊢ x✝ ∈ ↑(upperClosure s) ↔ x✝ ∈ ⋃ a ∈ s, Ici a
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.Bicone.ofLimitCone_π
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F f : J → C
t : Cone (Discrete.functor f)
ht : IsLimit t
j j' : J
⊢ (fun j => ht.lift (Fan.mk (f j) fun j' => if h : j = j' then eqToHom ⋯ else 0)) j ≫
      (fun j => t.π.app { as := j }) j' =
    if h : j = j' then eqToHom ⋯ else 0
state_after: no goals
tactic: simp
Theorem: List.mem_inter_of_mem_of_mem
File: Mathlib/Data/List/Lattice.lean

Proof steps:
state_before: α : Type u_1
l l₁ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
h₁ : a ∈ l₁
h₂ : a ∈ l₂
⊢ elem a l₂ = true
state_after: no goals
tactic: simpa using h₂
Theorem: Set.disjoint_right
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ Disjoint s t ↔ ∀ ⦃a : α⦄, a ∈ t → a ∉ s
state_after: no goals
tactic: rw [disjoint_comm, disjoint_left]
Theorem: Real.exp_eq_exp_ℝ
File: Mathlib/Analysis/SpecialFunctions/Exponential.lean

Proof steps:
state_before: ⊢ rexp = NormedSpace.exp ℝ
state_after: case h
x : ℝ
⊢ rexp x = NormedSpace.exp ℝ x
tactic: ext x
state_before: case h
x : ℝ
⊢ rexp x = NormedSpace.exp ℝ x
state_after: no goals
tactic: exact mod_cast congr_fun Complex.exp_eq_exp_ℂ x
Theorem: Nat.digit_sum_le
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n✝ p n : ℕ
⊢ (p.digits n).sum ≤ n
state_after: case zero
n p : ℕ
⊢ (p.digits 0).sum ≤ 0

case succ
n✝ p n : ℕ
a✝ : (p.digits n).sum ≤ n
⊢ (p.digits (n + 1)).sum ≤ n + 1
tactic: induction' n with n
Theorem: NumberField.mixedEmbedding.convexBodySumFactor_ne_zero
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
⊢ convexBodySumFactor K ≠ 0
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
⊢ 2 ^ NrRealPlaces K * (NNReal.pi / 2) ^ NrComplexPlaces K ≠ 0
tactic: refine div_ne_zero ?_ <| Nat.cast_ne_zero.mpr (Nat.factorial_ne_zero _)
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
⊢ 2 ^ NrRealPlaces K * (NNReal.pi / 2) ^ NrComplexPlaces K ≠ 0
state_after: no goals
tactic: exact mul_ne_zero (pow_ne_zero _ two_ne_zero)
    (pow_ne_zero _ (div_ne_zero NNReal.pi_ne_zero two_ne_zero))
Theorem: bot_lt_affineSpan
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
inst✝ : AffineSpace V P
ι : Type u_4
s : Set P
⊢ ⊥ < affineSpan k s ↔ s.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
inst✝ : AffineSpace V P
ι : Type u_4
s : Set P
⊢ affineSpan k s ≠ ⊥ ↔ s ≠ ∅
tactic: rw [bot_lt_iff_ne_bot, nonempty_iff_ne_empty]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : Set P
⊢ affineSpan k s ≠ ⊥ ↔ s ≠ ∅
state_after: no goals
tactic: exact (affineSpan_eq_bot _).not
Theorem: DifferentiableAt.hasGradientAt
File: Mathlib/Analysis/Calculus/Gradient/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
h : DifferentiableAt 𝕜 f x
⊢ HasGradientAt f (∇ f x) x
state_after: 𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
h : DifferentiableAt 𝕜 f x
⊢ HasFDerivAt f (fderiv 𝕜 f x) x
tactic: rw [hasGradientAt_iff_hasFDerivAt, gradient, (toDual 𝕜 F).apply_symm_apply (fderiv 𝕜 f x)]
state_before: 𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
h : DifferentiableAt 𝕜 f x
⊢ HasFDerivAt f (fderiv 𝕜 f x) x
state_after: no goals
tactic: exact h.hasFDerivAt
Theorem: PowerBasis.quotientEquivQuotientMinpolyMap_apply_mk
File: Mathlib/RingTheory/AdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
pb : PowerBasis R S
I : Ideal R
g : R[X]
⊢ (pb.quotientEquivQuotientMinpolyMap I) ((Ideal.Quotient.mk (Ideal.map (algebraMap R S) I)) ((aeval pb.gen) g)) =
    (Ideal.Quotient.mk (span {Polynomial.map (Ideal.Quotient.mk I) (minpoly R pb.gen)}))
      (Polynomial.map (Ideal.Quotient.mk I) g)
state_after: no goals
tactic: rw [PowerBasis.quotientEquivQuotientMinpolyMap, AlgEquiv.trans_apply, AlgEquiv.ofRingEquiv_apply,
    quotientEquiv_mk, AlgEquiv.coe_ringEquiv', AdjoinRoot.equiv'_symm_apply, PowerBasis.lift_aeval,
    AdjoinRoot.aeval_eq, AdjoinRoot.quotEquivQuotMap_apply_mk]
Theorem: Cardinal.mk_univ_real
File: Mathlib/Data/Real/Cardinality.lean

Proof steps:
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ #↑Set.univ = 𝔠
state_after: no goals
tactic: rw [mk_univ, mk_real]
Theorem: ContinuousLinearMap.comp_add
File: Mathlib/Topology/Algebra/Module/Basic.lean

Proof steps:
state_before: R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝¹⁹ : Semiring R₁
inst✝¹⁸ : Semiring R₂
inst✝¹⁷ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁶ : TopologicalSpace M₁
inst✝¹⁵ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹⁴ : TopologicalSpace M'₁
inst✝¹³ : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹² : TopologicalSpace M₂
inst✝¹¹ : AddCommMonoid M₂
M₃ : Type u_7
inst✝¹⁰ : TopologicalSpace M₃
inst✝⁹ : AddCommMonoid M₃
M₄ : Type u_8
inst✝⁸ : TopologicalSpace M₄
inst✝⁷ : AddCommMonoid M₄
inst✝⁶ : Module R₁ M₁
inst✝⁵ : Module R₁ M'₁
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : ContinuousAdd M₂
inst✝ : ContinuousAdd M₃
g : M₂ →SL[σ₂₃] M₃
f₁ f₂ : M₁ →SL[σ₁₂] M₂
⊢ g.comp (f₁ + f₂) = g.comp f₁ + g.comp f₂
state_after: case h
R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝¹⁹ : Semiring R₁
inst✝¹⁸ : Semiring R₂
inst✝¹⁷ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁶ : TopologicalSpace M₁
inst✝¹⁵ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹⁴ : TopologicalSpace M'₁
inst✝¹³ : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹² : TopologicalSpace M₂
inst✝¹¹ : AddCommMonoid M₂
M₃ : Type u_7
inst✝¹⁰ : TopologicalSpace M₃
inst✝⁹ : AddCommMonoid M₃
M₄ : Type u_8
inst✝⁸ : TopologicalSpace M₄
inst✝⁷ : AddCommMonoid M₄
inst✝⁶ : Module R₁ M₁
inst✝⁵ : Module R₁ M'₁
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : ContinuousAdd M₂
inst✝ : ContinuousAdd M₃
g : M₂ →SL[σ₂₃] M₃
f₁ f₂ : M₁ →SL[σ₁₂] M₂
x✝ : M₁
⊢ (g.comp (f₁ + f₂)) x✝ = (g.comp f₁ + g.comp f₂) x✝
tactic: ext
state_before: case h
R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝¹⁹ : Semiring R₁
inst✝¹⁸ : Semiring R₂
inst✝¹⁷ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁶ : TopologicalSpace M₁
inst✝¹⁵ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹⁴ : TopologicalSpace M'₁
inst✝¹³ : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹² : TopologicalSpace M₂
inst✝¹¹ : AddCommMonoid M₂
M₃ : Type u_7
inst✝¹⁰ : TopologicalSpace M₃
inst✝⁹ : AddCommMonoid M₃
M₄ : Type u_8
inst✝⁸ : TopologicalSpace M₄
inst✝⁷ : AddCommMonoid M₄
inst✝⁶ : Module R₁ M₁
inst✝⁵ : Module R₁ M'₁
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : ContinuousAdd M₂
inst✝ : ContinuousAdd M₃
g : M₂ →SL[σ₂₃] M₃
f₁ f₂ : M₁ →SL[σ₁₂] M₂
x✝ : M₁
⊢ (g.comp (f₁ + f₂)) x✝ = (g.comp f₁ + g.comp f₂) x✝
state_after: no goals
tactic: simp
Theorem: List.prev_nthLe
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
n : ℕ
hn : n < l.length
⊢ l.prev (l.nthLe n hn) ⋯ = l.nthLe ((n + (l.length - 1)) % l.length) ⋯
state_after: case nil
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
n : ℕ
h : [].Nodup
hn : n < [].length
⊢ [].prev ([].nthLe n hn) ⋯ = [].nthLe ((n + ([].length - 1)) % [].length) ⋯

case cons
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
n : ℕ
x : α
l : List α
h : (x :: l).Nodup
hn : n < (x :: l).length
⊢ (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
tactic: cases' l with x l
state_before: case cons
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
n : ℕ
x : α
l : List α
h : (x :: l).Nodup
hn : n < (x :: l).length
⊢ (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
state_after: case cons.nil
α : Type u_1
inst✝ : DecidableEq α
l : List α
x✝ : α
n : ℕ
x : α
h : [x].Nodup
hn : n < [x].length
⊢ [x].prev ([x].nthLe n hn) ⋯ = [x].nthLe ((n + ([x].length - 1)) % [x].length) ⋯

case cons.cons
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
n : ℕ
x : α
h : (x :: y :: l).Nodup
hn : n < (x :: y :: l).length
⊢ (x :: y :: l).prev ((x :: y :: l).nthLe n hn) ⋯ =
    (x :: y :: l).nthLe ((n + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯
tactic: induction' l with y l hl generalizing n x
Theorem: CategoryTheory.tensorRightHomEquiv_tensor
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Z ⊗ Y'
g : X' ⟶ Z'
⊢ (tensorRightHomEquiv (X' ⊗ X) Y Y' (Z' ⊗ Z)).symm ((g ⊗ f) ≫ (α_ Z' Z Y').inv) =
    (α_ X' X Y).hom ≫ (g ⊗ (tensorRightHomEquiv X Y Y' Z).symm f)
state_after: no goals
tactic: simp [tensorRightHomEquiv, tensorHom_def]
Theorem: Matroid.ofMatroid_lt_iff
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M✝ : Matroid α
R I J X Y : Set α
N M M' : Matroid α
⊢ { toMatroid := M } < { toMatroid := M' } ↔ M <r M'
state_after: no goals
tactic: simp
Theorem: Fin.range_cons
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x✝ : α✝ 0
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ i.succ
i : Fin n✝
y : α✝ i.succ
z : α✝ 0
α : Type u_1
n : ℕ
x : α
b : Fin n → α
⊢ Set.range (cons x b) = insert x (Set.range b)
state_after: no goals
tactic: rw [range_fin_succ, cons_zero, tail_cons]
Theorem: Filter.prod_iInf_left
File: Mathlib/Order/Filter/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
inst✝ : Nonempty ι
f : ι → Filter α
g : Filter β
⊢ (⨅ i, f i) ×ˢ g = ⨅ i, f i ×ˢ g
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
inst✝ : Nonempty ι
f : ι → Filter α
g : Filter β
⊢ (⨅ i, f i).prod g = ⨅ i, (f i).prod g
tactic: dsimp only [SProd.sprod]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
inst✝ : Nonempty ι
f : ι → Filter α
g : Filter β
⊢ (⨅ i, f i).prod g = ⨅ i, (f i).prod g
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
inst✝ : Nonempty ι
f : ι → Filter α
g : Filter β
⊢ ⨅ x, comap Prod.fst (f x) ⊓ comap Prod.snd g = ⨅ i, (f i).prod g
tactic: rw [Filter.prod, comap_iInf, iInf_inf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
inst✝ : Nonempty ι
f : ι → Filter α
g : Filter β
⊢ ⨅ x, comap Prod.fst (f x) ⊓ comap Prod.snd g = ⨅ i, (f i).prod g
state_after: no goals
tactic: simp only [Filter.prod, eq_self_iff_true]
Theorem: Inducing.continuousWithinAt_iff
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → γ
hg : Inducing g
s : Set α
x : α
⊢ ContinuousWithinAt f s x ↔ ContinuousWithinAt (g ∘ f) s x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → γ
hg : Inducing g
s : Set α
x : α
⊢ Tendsto (g ∘ f) (𝓝[s] x) (𝓝 (g (f x))) ↔ Tendsto (g ∘ f) (𝓝[s] x) (𝓝 ((g ∘ f) x))
tactic: simp_rw [ContinuousWithinAt, Inducing.tendsto_nhds_iff hg]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → γ
hg : Inducing g
s : Set α
x : α
⊢ Tendsto (g ∘ f) (𝓝[s] x) (𝓝 (g (f x))) ↔ Tendsto (g ∘ f) (𝓝[s] x) (𝓝 ((g ∘ f) x))
state_after: no goals
tactic: rfl
Theorem: Function.Commute.minimalPeriod_of_comp_eq_mul_of_coprime
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
g : α → α
h : Function.Commute f g
hco : (minimalPeriod f x).Coprime (minimalPeriod g x)
⊢ minimalPeriod (f ∘ g) x = minimalPeriod f x * minimalPeriod g x
state_after: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
g : α → α
h : Function.Commute f g
hco : (minimalPeriod f x).Coprime (minimalPeriod g x)
⊢ minimalPeriod f x * minimalPeriod g x ∣ minimalPeriod (f ∘ g) x
tactic: apply h.minimalPeriod_of_comp_dvd_mul.antisymm
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
g : α → α
h : Function.Commute f g
hco : (minimalPeriod f x).Coprime (minimalPeriod g x)
⊢ minimalPeriod f x * minimalPeriod g x ∣ minimalPeriod (f ∘ g) x
state_after: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
g : α → α
h : Function.Commute f g
hco : (minimalPeriod f x).Coprime (minimalPeriod g x)
⊢ ∀ {f g : α → α},
    Function.Commute f g → (minimalPeriod f x).Coprime (minimalPeriod g x) → minimalPeriod f x ∣ minimalPeriod (f ∘ g) x
tactic: suffices
    ∀ {f g : α → α},
      Commute f g →
        Coprime (minimalPeriod f x) (minimalPeriod g x) →
          minimalPeriod f x ∣ minimalPeriod (f ∘ g) x from
    hco.mul_dvd_of_dvd_of_dvd (this h hco) (h.comp_eq.symm ▸ this h.symm hco.symm)
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
g : α → α
h : Function.Commute f g
hco : (minimalPeriod f x).Coprime (minimalPeriod g x)
⊢ ∀ {f g : α → α},
    Function.Commute f g → (minimalPeriod f x).Coprime (minimalPeriod g x) → minimalPeriod f x ∣ minimalPeriod (f ∘ g) x
state_after: α : Type u_1
β : Type u_2
f✝ fa : α → α
fb : β → β
x y : α
m n : ℕ
g✝ : α → α
h✝ : Function.Commute f✝ g✝
hco✝ : (minimalPeriod f✝ x).Coprime (minimalPeriod g✝ x)
f g : α → α
h : Function.Commute f g
hco : (minimalPeriod f x).Coprime (minimalPeriod g x)
⊢ minimalPeriod f x ∣ minimalPeriod (f ∘ g) x
tactic: intro f g h hco
state_before: α : Type u_1
β : Type u_2
f✝ fa : α → α
fb : β → β
x y : α
m n : ℕ
g✝ : α → α
h✝ : Function.Commute f✝ g✝
hco✝ : (minimalPeriod f✝ x).Coprime (minimalPeriod g✝ x)
f g : α → α
h : Function.Commute f g
hco : (minimalPeriod f x).Coprime (minimalPeriod g x)
⊢ minimalPeriod f x ∣ minimalPeriod (f ∘ g) x
state_after: case refine_1
α : Type u_1
β : Type u_2
f✝ fa : α → α
fb : β → β
x y : α
m n : ℕ
g✝ : α → α
h✝ : Function.Commute f✝ g✝
hco✝ : (minimalPeriod f✝ x).Coprime (minimalPeriod g✝ x)
f g : α → α
h : Function.Commute f g
hco : (minimalPeriod f x).Coprime (minimalPeriod g x)
⊢ IsPeriodicPt (f ∘ g) (minimalPeriod g x * minimalPeriod (f ∘ g) x) x

case refine_2
α : Type u_1
β : Type u_2
f✝ fa : α → α
fb : β → β
x y : α
m n : ℕ
g✝ : α → α
h✝ : Function.Commute f✝ g✝
hco✝ : (minimalPeriod f✝ x).Coprime (minimalPeriod g✝ x)
f g : α → α
h : Function.Commute f g
hco : (minimalPeriod f x).Coprime (minimalPeriod g x)
⊢ IsPeriodicPt g (minimalPeriod g x * minimalPeriod (f ∘ g) x) x
tactic: refine hco.dvd_of_dvd_mul_left (IsPeriodicPt.left_of_comp h ?_ ?_).minimalPeriod_dvd
Theorem: List.inj_on_of_nodup_map
File: Mathlib/Data/List/Nodup.lean

Proof steps:
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
f : α → β
l : List α
d : (map f l).Nodup
⊢ ∀ ⦃x : α⦄, x ∈ l → ∀ ⦃y : α⦄, y ∈ l → f x = f y → x = y
state_after: case nil
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
f : α → β
d : (map f []).Nodup
⊢ ∀ ⦃x : α⦄, x ∈ [] → ∀ ⦃y : α⦄, y ∈ [] → f x = f y → x = y

case cons
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
f : α → β
hd : α
tl : List α
ih : (map f tl).Nodup → ∀ ⦃x : α⦄, x ∈ tl → ∀ ⦃y : α⦄, y ∈ tl → f x = f y → x = y
d : (map f (hd :: tl)).Nodup
⊢ ∀ ⦃x : α⦄, x ∈ hd :: tl → ∀ ⦃y : α⦄, y ∈ hd :: tl → f x = f y → x = y
tactic: induction' l with hd tl ih
Theorem: compl_frontier_eq_union_interior
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ (frontier s)ᶜ = interior s ∪ interior sᶜ
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ ((interior s)ᶜ ∩ (interior sᶜ)ᶜ)ᶜ = interior s ∪ interior sᶜ
tactic: rw [frontier_eq_inter_compl_interior]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ ((interior s)ᶜ ∩ (interior sᶜ)ᶜ)ᶜ = interior s ∪ interior sᶜ
state_after: no goals
tactic: simp only [compl_inter, compl_compl]
Theorem: Set.image_const_add_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ (fun x => a + x) '' [[b, c]] = [[a + b, a + c]]
state_after: no goals
tactic: simp [add_comm]
Theorem: CategoryTheory.Presieve.FamilyOfElements.comp_of_compatible
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S✝ : Sieve X
R : Presieve X
S : Sieve X
x : FamilyOfElements P S.arrows
t : x.Compatible
f : Y ⟶ X
hf : S.arrows f
Z : C
g : Z ⟶ Y
⊢ x (g ≫ f) ⋯ = P.map g.op (x f hf)
state_after: no goals
tactic: simpa using t (𝟙 _) g (S.downward_closed hf g) hf (id_comp _)
Theorem: Polynomial.cyclotomic_three
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Ring R
⊢ cyclotomic 3 R = X ^ 2 + X + 1
state_after: no goals
tactic: simp [cyclotomic_prime, sum_range_succ']
Theorem: Real.hasDerivWithinAt_arcsin_Ici
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean

Proof steps:
state_before: x : ℝ
h : x ≠ -1
⊢ HasDerivWithinAt arcsin (1 / √(1 - x ^ 2)) (Ici x) x
state_after: case inl
h : 1 ≠ -1
⊢ HasDerivWithinAt arcsin (1 / √(1 - 1 ^ 2)) (Ici 1) 1

case inr
x : ℝ
h : x ≠ -1
h' : x ≠ 1
⊢ HasDerivWithinAt arcsin (1 / √(1 - x ^ 2)) (Ici x) x
tactic: rcases eq_or_ne x 1 with (rfl | h')
Theorem: mem_nhdsWithin_Iic_iff_exists_Ioc_subset'
File: Mathlib/Topology/Order/LeftRightNhds.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a l' : α
s : Set α
hl' : l' < a
⊢ [s ∈ 𝓝[≤] a, s ∈ 𝓝[Icc l' a] a, s ∈ 𝓝[Ioc l' a] a, ∃ l ∈ Ico l' a, Ioc l a ⊆ s, ∃ l ∈ Iio a, Ioc l a ⊆ s].get? 0 =
    some (s ∈ 𝓝[≤] a)
state_after: no goals
tactic: norm_num
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a l' : α
s : Set α
hl' : l' < a
⊢ [s ∈ 𝓝[≤] a, s ∈ 𝓝[Icc l' a] a, s ∈ 𝓝[Ioc l' a] a, ∃ l ∈ Ico l' a, Ioc l a ⊆ s, ∃ l ∈ Iio a, Ioc l a ⊆ s].get? 4 =
    some (∃ l ∈ Iio a, Ioc l a ⊆ s)
state_after: no goals
tactic: norm_num