ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: HomologicalComplex.singleObjHomologySelfIso_hom_singleObjOpcyclesSelfIso_hom
File: Mathlib/Algebra/Homology/SingleHomology.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroObject C
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A : C
⊢ (singleObjHomologySelfIso c j A).hom ≫ (singleObjOpcyclesSelfIso c j A).hom = ((single C c j).obj A).homologyι j
state_after: no goals
tactic: rw [← cancel_epi (singleObjHomologySelfIso _ _ _).inv,
    Iso.inv_hom_id_assoc, singleObjHomologySelfIso_inv_homologyι]
Theorem: CategoryTheory.Tor'_map_app'
File: Mathlib/CategoryTheory/Monoidal/Tor.lean

Proof steps:
state_before: C : Type u_1
inst✝⁴ : Category.{u_2, u_1} C
inst✝³ : MonoidalCategory C
inst✝² : Abelian C
inst✝¹ : MonoidalPreadditive C
inst✝ : HasProjectiveResolutions C
n : ℕ
X Y : C
f : X ⟶ Y
Z : C
⊢ ((Tor' C n).map f).app Z = (((tensoringRight C).obj Z).leftDerived n).map f
state_after: no goals
tactic: rfl
Theorem: AddCommGrp.image.lift_fac
File: Mathlib/Algebra/Category/Grp/Images.lean

Proof steps:
state_before: G H : AddCommGrp
f : G ⟶ H
F' : MonoFactorisation f
⊢ lift F' ≫ F'.m = ι f
state_after: case w
G H : AddCommGrp
f : G ⟶ H
F' : MonoFactorisation f
x : ↑(image f)
⊢ (lift F' ≫ F'.m) x = (ι f) x
tactic: ext x
state_before: case w
G H : AddCommGrp
f : G ⟶ H
F' : MonoFactorisation f
x : ↑(image f)
⊢ (lift F' ≫ F'.m) x = (ι f) x
state_after: case w
G H : AddCommGrp
f : G ⟶ H
F' : MonoFactorisation f
x : ↑(image f)
⊢ (F'.e ≫ F'.m) ↑(Classical.indefiniteDescription (fun x_1 => f x_1 = ↑x) ⋯) = (ι f) x
tactic: change (F'.e ≫ F'.m) _ = _
state_before: case w
G H : AddCommGrp
f : G ⟶ H
F' : MonoFactorisation f
x : ↑(image f)
⊢ (F'.e ≫ F'.m) ↑(Classical.indefiniteDescription (fun x_1 => f x_1 = ↑x) ⋯) = (ι f) x
state_after: case w
G H : AddCommGrp
f : G ⟶ H
F' : MonoFactorisation f
x : ↑(image f)
⊢ ↑x = (ι f) x
tactic: rw [F'.fac, (Classical.indefiniteDescription _ x.2).2]
state_before: case w
G H : AddCommGrp
f : G ⟶ H
F' : MonoFactorisation f
x : ↑(image f)
⊢ ↑x = (ι f) x
state_after: no goals
tactic: rfl
Theorem: Matrix.coe_units_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
u : Mˣ
n : ℕ
⊢ ↑(u ^ ↑n) = ↑u ^ ↑n
state_after: no goals
tactic: rw [zpow_natCast, zpow_natCast, Units.val_pow_eq_pow_val]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
u : Mˣ
k : ℕ
⊢ ↑(u ^ -[k+1]) = ↑u ^ -[k+1]
state_after: no goals
tactic: rw [zpow_negSucc, zpow_negSucc, ← inv_pow, u⁻¹.val_pow_eq_pow_val, ← inv_pow', coe_units_inv]
Theorem: NonUnitalSubsemiring.unitization_range
File: Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝¹ : Semiring R
inst✝ : SetLike S R
hSR : NonUnitalSubsemiringClass S R
s : S
⊢ (unitization s).range = subalgebraOfSubsemiring (Subsemiring.closure ↑s)
state_after: R : Type u_1
S : Type u_2
inst✝¹ : Semiring R
inst✝ : SetLike S R
hSR : NonUnitalSubsemiringClass S R
s : S
this : SMulMemClass S ℕ R
⊢ (unitization s).range = subalgebraOfSubsemiring (Subsemiring.closure ↑s)
tactic: have := AddSubmonoidClass.nsmulMemClass (S := S)
state_before: R : Type u_1
S : Type u_2
inst✝¹ : Semiring R
inst✝ : SetLike S R
hSR : NonUnitalSubsemiringClass S R
s : S
this : SMulMemClass S ℕ R
⊢ (unitization s).range = subalgebraOfSubsemiring (Subsemiring.closure ↑s)
state_after: no goals
tactic: rw [unitization, NonUnitalSubalgebra.unitization_range (hSRA := this), Algebra.adjoin_nat]
Theorem: ProbabilityTheory.Kernel.measure_sum_seq
File: Mathlib/Probability/Kernel/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ κ : Kernel α β
h : IsSFiniteKernel κ
a : α
⊢ (Measure.sum fun n => (κ.seq n) a) = κ a
state_after: no goals
tactic: rw [← Kernel.sum_apply, kernel_sum_seq κ]
Theorem: subsingleton_of_disjoint_isOpen_iUnion_eq_univ
File: Mathlib/Topology/Connected/Clopen.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : PreconnectedSpace α
s : ι → Set α
h_nonempty : ∀ (i : ι), (s i).Nonempty
h_disj : Pairwise (Disjoint on s)
h_open : ∀ (i : ι), IsOpen (s i)
h_Union : ⋃ i, s i = univ
⊢ Subsingleton ι
state_after: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : PreconnectedSpace α
s : ι → Set α
h_nonempty : ∀ (i : ι), (s i).Nonempty
h_disj : Pairwise (Disjoint on s)
h_open : ∀ (i : ι), IsOpen (s i)
h_Union : ⋃ i, s i = univ
i : ι
⊢ IsClosed (s i)
tactic: refine subsingleton_of_disjoint_isClopen h_nonempty h_disj (fun i ↦ ⟨?_, h_open i⟩)
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : PreconnectedSpace α
s : ι → Set α
h_nonempty : ∀ (i : ι), (s i).Nonempty
h_disj : Pairwise (Disjoint on s)
h_open : ∀ (i : ι), IsOpen (s i)
h_Union : ⋃ i, s i = univ
i : ι
⊢ IsClosed (s i)
state_after: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : PreconnectedSpace α
s : ι → Set α
h_nonempty : ∀ (i : ι), (s i).Nonempty
h_disj : Pairwise (Disjoint on s)
h_open : ∀ (i : ι), IsOpen (s i)
h_Union : ⋃ i, s i = univ
i : ι
⊢ IsOpen (⋃ i_1, s i_1 \ s i)
tactic: rw [← isOpen_compl_iff, compl_eq_univ_diff, ← h_Union, iUnion_diff]
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : PreconnectedSpace α
s : ι → Set α
h_nonempty : ∀ (i : ι), (s i).Nonempty
h_disj : Pairwise (Disjoint on s)
h_open : ∀ (i : ι), IsOpen (s i)
h_Union : ⋃ i, s i = univ
i : ι
⊢ IsOpen (⋃ i_1, s i_1 \ s i)
state_after: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : PreconnectedSpace α
s : ι → Set α
h_nonempty : ∀ (i : ι), (s i).Nonempty
h_disj : Pairwise (Disjoint on s)
h_open : ∀ (i : ι), IsOpen (s i)
h_Union : ⋃ i, s i = univ
i j : ι
⊢ IsOpen (s j \ s i)
tactic: refine isOpen_iUnion (fun j ↦ ?_)
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : PreconnectedSpace α
s : ι → Set α
h_nonempty : ∀ (i : ι), (s i).Nonempty
h_disj : Pairwise (Disjoint on s)
h_open : ∀ (i : ι), IsOpen (s i)
h_Union : ⋃ i, s i = univ
i j : ι
⊢ IsOpen (s j \ s i)
state_after: case inl
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : PreconnectedSpace α
s : ι → Set α
h_nonempty : ∀ (i : ι), (s i).Nonempty
h_disj : Pairwise (Disjoint on s)
h_open : ∀ (i : ι), IsOpen (s i)
h_Union : ⋃ i, s i = univ
i : ι
⊢ IsOpen (s i \ s i)

case inr
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : PreconnectedSpace α
s : ι → Set α
h_nonempty : ∀ (i : ι), (s i).Nonempty
h_disj : Pairwise (Disjoint on s)
h_open : ∀ (i : ι), IsOpen (s i)
h_Union : ⋃ i, s i = univ
i j : ι
h_ne : i ≠ j
⊢ IsOpen (s j \ s i)
tactic: rcases eq_or_ne i j with rfl | h_ne
Theorem: CategoryTheory.Limits.Cofork.ofπ_ι_app
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f✝ g : X ⟶ Y
P : C
π : Y ⟶ P
w : f✝ ≫ π = g ≫ π
i j : WalkingParallelPair
f : i ⟶ j
⊢ (parallelPair f✝ g).map f ≫ (fun X_1 => WalkingParallelPair.casesOn X_1 (f✝ ≫ π) π) j =
    (fun X_1 => WalkingParallelPair.casesOn X_1 (f✝ ≫ π) π) i ≫ ((Functor.const WalkingParallelPair).obj P).map f
state_after: no goals
tactic: cases f <;> dsimp <;> simp [w]
Theorem: Equiv.Perm.mem_iff_ofSubtype_apply_mem
File: Mathlib/GroupTheory/Perm/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
p : α → Prop
f✝ : Perm α
inst✝ : DecidablePred p
a : α
f : Perm (Subtype p)
x : α
h : p x
⊢ p x ↔ p ((ofSubtype f) x)
state_after: no goals
tactic: simpa only [h, true_iff_iff, MonoidHom.coe_mk, ofSubtype_apply_of_mem f h] using (f ⟨x, h⟩).2
state_before: α : Type u
β : Type v
p : α → Prop
f✝ : Perm α
inst✝ : DecidablePred p
a : α
f : Perm (Subtype p)
x : α
h : ¬p x
⊢ p x ↔ p ((ofSubtype f) x)
state_after: no goals
tactic: simp [h, ofSubtype_apply_of_not_mem f h]
Theorem: AffineSubspace.affineSpan_parallel_iff_vectorSpan_eq_and_eq_empty_iff_eq_empty
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
s₁ s₂ : Set P
⊢ affineSpan k s₁ ∥ affineSpan k s₂ ↔ vectorSpan k s₁ = vectorSpan k s₂ ∧ (s₁ = ∅ ↔ s₂ = ∅)
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
s₁ s₂ : Set P
⊢ affineSpan k s₁ ∥ affineSpan k s₂ ↔
    (affineSpan k s₁).direction = (affineSpan k s₂).direction ∧ (affineSpan k s₁ = ⊥ ↔ affineSpan k s₂ = ⊥)
tactic: repeat rw [← direction_affineSpan, ← affineSpan_eq_bot k]
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
s₁ s₂ : Set P
⊢ affineSpan k s₁ ∥ affineSpan k s₂ ↔
    (affineSpan k s₁).direction = (affineSpan k s₂).direction ∧ (affineSpan k s₁ = ⊥ ↔ affineSpan k s₂ = ⊥)
state_after: no goals
tactic: exact parallel_iff_direction_eq_and_eq_bot_iff_eq_bot
Theorem: MonotoneOn.sum_le_integral_Ico
File: Mathlib/Analysis/SumIntegralComparisons.lean

Proof steps:
state_before: x₀ : ℝ
a b : ℕ
f : ℝ → ℝ
hab : a ≤ b
hf : MonotoneOn f (Icc ↑a ↑b)
⊢ ∑ x ∈ Finset.Ico a b, f ↑x ≤ ∫ (x : ℝ) in ↑a..↑b, f x
state_after: x₀ : ℝ
a b : ℕ
f : ℝ → ℝ
hab : a ≤ b
hf : MonotoneOn f (Icc ↑a ↑b)
⊢ ∫ (x : ℝ) in ↑a..↑b, -f x ≤ ∑ x ∈ Finset.Ico a b, -f ↑x
tactic: rw [← neg_le_neg_iff, ← Finset.sum_neg_distrib, ← intervalIntegral.integral_neg]
state_before: x₀ : ℝ
a b : ℕ
f : ℝ → ℝ
hab : a ≤ b
hf : MonotoneOn f (Icc ↑a ↑b)
⊢ ∫ (x : ℝ) in ↑a..↑b, -f x ≤ ∑ x ∈ Finset.Ico a b, -f ↑x
state_after: no goals
tactic: exact hf.neg.integral_le_sum_Ico hab
Theorem: Bool.and_intro
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: ⊢ ∀ {a b : Bool}, a = true → b = true → (a && b) = true
state_after: no goals
tactic: decide
Theorem: DFA.mem_accepts
File: Mathlib/Computability/DFA.lean

Proof steps:
state_before: α : Type u
σ : Type v
M : DFA α σ
x : List α
⊢ x ∈ M.accepts ↔ M.eval x ∈ M.accept
state_after: no goals
tactic: rfl
Theorem: Fin.insertNth_comp_rev
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
β : Type v
α : Type u_1
i : Fin (n + 1)
x : α
p : Fin n → α
⊢ i.insertNth x p ∘ rev = i.rev.insertNth x (p ∘ rev)
state_after: case h
m n : ℕ
α✝ : Fin (n + 1) → Type u
β : Type v
α : Type u_1
i : Fin (n + 1)
x✝ : α
p : Fin n → α
x : Fin (n + 1)
⊢ (i.insertNth x✝ p ∘ rev) x = i.rev.insertNth x✝ (p ∘ rev) x
tactic: funext x
state_before: case h
m n : ℕ
α✝ : Fin (n + 1) → Type u
β : Type v
α : Type u_1
i : Fin (n + 1)
x✝ : α
p : Fin n → α
x : Fin (n + 1)
⊢ (i.insertNth x✝ p ∘ rev) x = i.rev.insertNth x✝ (p ∘ rev) x
state_after: no goals
tactic: apply insertNth_rev
Theorem: Finsupp.rangeIcc_toFun
File: Mathlib/Data/Finsupp/Interval.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : Zero α
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
f✝ g✝ : ι →₀ α
i✝ : ι
a : α
f g : ι →₀ α
i : ι
⊢ i ∈ f.support ∪ g.support ↔ (fun i => Icc (f i) (g i)) i ≠ 0
state_after: ι : Type u_1
α : Type u_2
inst✝² : Zero α
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
f✝ g✝ : ι →₀ α
i✝ : ι
a : α
f g : ι →₀ α
i : ι
⊢ f i = 0 ∧ g i = 0 ↔ (fun i => Icc (f i) (g i)) i = 0
tactic: rw [mem_union, ← not_iff_not, not_or, not_mem_support_iff, not_mem_support_iff, not_ne_iff]
state_before: ι : Type u_1
α : Type u_2
inst✝² : Zero α
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
f✝ g✝ : ι →₀ α
i✝ : ι
a : α
f g : ι →₀ α
i : ι
⊢ f i = 0 ∧ g i = 0 ↔ (fun i => Icc (f i) (g i)) i = 0
state_after: no goals
tactic: exact Icc_eq_singleton_iff.symm
Theorem: CategoryTheory.prodOpEquiv_unitIso
File: Mathlib/CategoryTheory/Products/Basic.lean

Proof steps:
state_before: A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
x✝ : (C × D)ᵒᵖ
X : C
Y : D
⊢ { obj := fun X => (op (unop X).1, op (unop X).2), map := fun {X Y} f => (f.unop.1.op, f.unop.2.op), map_id := ⋯,
            map_comp := ⋯ }.map
        ((Iso.refl (𝟭 (C × D)ᵒᵖ)).hom.app (op (X, Y))) ≫
      (Iso.refl
              ({
                  obj := fun x =>
                    match x with
                    | (X, Y) => op (unop X, unop Y),
                  map := fun {X Y} x =>
                    match x with
                    | (f, g) => op (f.unop, g.unop),
                  map_id := ⋯, map_comp := ⋯ } ⋙
                { obj := fun X => (op (unop X).1, op (unop X).2), map := fun {X Y} f => (f.unop.1.op, f.unop.2.op),
                  map_id := ⋯, map_comp := ⋯ })).hom.app
        ({ obj := fun X => (op (unop X).1, op (unop X).2), map := fun {X Y} f => (f.unop.1.op, f.unop.2.op),
              map_id := ⋯, map_comp := ⋯ }.obj
          (op (X, Y))) =
    𝟙
      ({ obj := fun X => (op (unop X).1, op (unop X).2), map := fun {X Y} f => (f.unop.1.op, f.unop.2.op), map_id := ⋯,
            map_comp := ⋯ }.obj
        (op (X, Y)))
state_after: A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
x✝ : (C × D)ᵒᵖ
X : C
Y : D
⊢ (𝟙 (op X) ≫ 𝟙 (op X), 𝟙 (op Y) ≫ 𝟙 (op Y)) = (𝟙 (op X), 𝟙 (op Y))
tactic: dsimp
state_before: A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
x✝ : (C × D)ᵒᵖ
X : C
Y : D
⊢ (𝟙 (op X) ≫ 𝟙 (op X), 𝟙 (op Y) ≫ 𝟙 (op Y)) = (𝟙 (op X), 𝟙 (op Y))
state_after: no goals
tactic: ext <;> apply Category.id_comp
Theorem: PartialHomeomorph.map_extend_nhdsWithin_eq_image_of_subset
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
y : M
hy : y ∈ f.source
hs : s ⊆ f.source
⊢ map (↑(f.extend I)) (𝓝[s] y) = 𝓝[↑(f.extend I) '' s] ↑(f.extend I) y
state_after: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
y : M
hy : y ∈ f.source
hs : s ⊆ f.source
⊢ s ⊆ (f.extend I).source
tactic: rw [map_extend_nhdsWithin_eq_image _ _ hy, inter_eq_self_of_subset_right]
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
y : M
hy : y ∈ f.source
hs : s ⊆ f.source
⊢ s ⊆ (f.extend I).source
state_after: no goals
tactic: rwa [extend_source]
Theorem: CompleteLattice.inf_continuous
File: Mathlib/Order/OmegaCompletePartialOrder.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLinearOrder β
f g : α →o β
hf : Continuous f
hg : Continuous g
⊢ Continuous (f ⊓ g)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLinearOrder β
f g : α →o β
hf : Continuous f
hg : Continuous g
c : Chain α
z : β
⊢ (f ⊓ g) (ωSup c) ≤ z ↔ ωSup (c.map (f ⊓ g)) ≤ z
tactic: refine fun c => eq_of_forall_ge_iff fun z => ?_
state_before: α : Type u_1
β : Type u_2
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLinearOrder β
f g : α →o β
hf : Continuous f
hg : Continuous g
c : Chain α
z : β
⊢ (f ⊓ g) (ωSup c) ≤ z ↔ ωSup (c.map (f ⊓ g)) ≤ z
state_after: α : Type u_1
β : Type u_2
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLinearOrder β
f g : α →o β
hf : Continuous f
hg : Continuous g
c : Chain α
z : β
⊢ (∀ (x x_1 : ℕ), f (c x_1) ≤ z ∨ g (c x) ≤ z) ↔ ∀ (i : ℕ), f (c i) ≤ z ∨ g (c i) ≤ z
tactic: simp only [inf_le_iff, hf c, hg c, ωSup_le_iff, ← forall_or_left, ← forall_or_right,
             Chain.map_coe, OrderHom.coe_inf, Pi.inf_apply, Function.comp]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLinearOrder β
f g : α →o β
hf : Continuous f
hg : Continuous g
c : Chain α
z : β
⊢ (∀ (x x_1 : ℕ), f (c x_1) ≤ z ∨ g (c x) ≤ z) ↔ ∀ (i : ℕ), f (c i) ≤ z ∨ g (c i) ≤ z
state_after: no goals
tactic: exact ⟨fun h _ ↦ h _ _, fun h i j ↦
    (h (max j i)).imp (le_trans <| f.mono <| c.mono <| le_max_left _ _)
      (le_trans <| g.mono <| c.mono <| le_max_right _ _)⟩
Theorem: Ordinal.mod_opow_log_lt_self
File: Mathlib/SetTheory/Ordinal/Exponential.lean

Proof steps:
state_before: b o : Ordinal.{u_1}
ho : o ≠ 0
⊢ o % b ^ log b o < o
state_after: case inl
o : Ordinal.{u_1}
ho : o ≠ 0
⊢ o % 0 ^ log 0 o < o

case inr
b o : Ordinal.{u_1}
ho : o ≠ 0
hb : b ≠ 0
⊢ o % b ^ log b o < o
tactic: rcases eq_or_ne b 0 with (rfl | hb)
Theorem: Polynomial.aroots_C_mul
File: Mathlib/Algebra/Polynomial/Roots.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
p✝ q : R[X]
inst✝⁴ : CommRing T
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : Algebra T S
inst✝ : NoZeroSMulDivisors T S
a : T
p : T[X]
ha : a ≠ 0
⊢ (C a * p).aroots S = p.aroots S
state_after: case ha
R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
p✝ q : R[X]
inst✝⁴ : CommRing T
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : Algebra T S
inst✝ : NoZeroSMulDivisors T S
a : T
p : T[X]
ha : a ≠ 0
⊢ (algebraMap T S) a ≠ 0
tactic: rw [aroots_def, Polynomial.map_mul, map_C, roots_C_mul]
state_before: case ha
R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
p✝ q : R[X]
inst✝⁴ : CommRing T
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : Algebra T S
inst✝ : NoZeroSMulDivisors T S
a : T
p : T[X]
ha : a ≠ 0
⊢ (algebraMap T S) a ≠ 0
state_after: case ha.hf
R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
p✝ q : R[X]
inst✝⁴ : CommRing T
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : Algebra T S
inst✝ : NoZeroSMulDivisors T S
a : T
p : T[X]
ha : a ≠ 0
⊢ Function.Injective ⇑(algebraMap T S)
tactic: rwa [map_ne_zero_iff]
state_before: case ha.hf
R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
p✝ q : R[X]
inst✝⁴ : CommRing T
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : Algebra T S
inst✝ : NoZeroSMulDivisors T S
a : T
p : T[X]
ha : a ≠ 0
⊢ Function.Injective ⇑(algebraMap T S)
state_after: no goals
tactic: exact NoZeroSMulDivisors.algebraMap_injective T S
Theorem: UniformContinuous₂.tendstoUniformly
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : UniformSpace β
F : ι → α → β
f✝ : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝¹ : UniformSpace α
inst✝ : UniformSpace γ
f : α → β → γ
h : UniformContinuous₂ f
x : α
⊢ UniformContinuousOn (↿f) (univ ×ˢ univ)
state_after: no goals
tactic: rwa [univ_prod_univ, uniformContinuousOn_univ]
Theorem: Matrix.SpecialLinearGroup.fin_two_induction
File: Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean

Proof steps:
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
a b c d : R
hdet : a * d - b * c = 1
⊢ !![a, b; c, d].det = 1
state_after: no goals
tactic: rwa [det_fin_two_of]
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
h : ∀ (a b c d : R) (hdet : a * d - b * c = 1), P ⟨!![a, b; c, d], ⋯⟩
g : SL(2, R)
⊢ P g
state_after: case mk
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
h : ∀ (a b c d : R) (hdet : a * d - b * c = 1), P ⟨!![a, b; c, d], ⋯⟩
m : Matrix (Fin 2) (Fin 2) R
hm : m.det = 1
⊢ P ⟨m, hm⟩
tactic: obtain ⟨m, hm⟩ := g
state_before: case mk
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
h : ∀ (a b c d : R) (hdet : a * d - b * c = 1), P ⟨!![a, b; c, d], ⋯⟩
m : Matrix (Fin 2) (Fin 2) R
hm : m.det = 1
⊢ P ⟨m, hm⟩
state_after: case h.e'_1.h.e'_3
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
h : ∀ (a b c d : R) (hdet : a * d - b * c = 1), P ⟨!![a, b; c, d], ⋯⟩
m : Matrix (Fin 2) (Fin 2) R
hm : m.det = 1
⊢ m = !![m 0 0, m 0 1; m 1 0, m 1 1]
tactic: convert h (m 0 0) (m 0 1) (m 1 0) (m 1 1) (by rwa [det_fin_two] at hm)
state_before: case h.e'_1.h.e'_3
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
h : ∀ (a b c d : R) (hdet : a * d - b * c = 1), P ⟨!![a, b; c, d], ⋯⟩
m : Matrix (Fin 2) (Fin 2) R
hm : m.det = 1
⊢ m = !![m 0 0, m 0 1; m 1 0, m 1 1]
state_after: case h.e'_1.h.e'_3.a
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
h : ∀ (a b c d : R) (hdet : a * d - b * c = 1), P ⟨!![a, b; c, d], ⋯⟩
m : Matrix (Fin 2) (Fin 2) R
hm : m.det = 1
i j : Fin 2
⊢ m i j = !![m 0 0, m 0 1; m 1 0, m 1 1] i j
tactic: ext i j
state_before: case h.e'_1.h.e'_3.a
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
h : ∀ (a b c d : R) (hdet : a * d - b * c = 1), P ⟨!![a, b; c, d], ⋯⟩
m : Matrix (Fin 2) (Fin 2) R
hm : m.det = 1
i j : Fin 2
⊢ m i j = !![m 0 0, m 0 1; m 1 0, m 1 1] i j
state_after: no goals
tactic: fin_cases i <;> fin_cases j <;> rfl
Theorem: Complex.tan_periodic
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: ⊢ Function.Periodic tan ↑π
state_after: no goals
tactic: simpa only [tan_eq_sin_div_cos] using sin_antiperiodic.div cos_antiperiodic
Theorem: jacobiSym.list_prod_left
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

Proof steps:
state_before: l : List ℤ
n : ℕ
⊢ J(l.prod | n) = (List.map (fun a => J(a | n)) l).prod
state_after: case nil
n : ℕ
⊢ J([].prod | n) = (List.map (fun a => J(a | n)) []).prod

case cons
n✝ : ℕ
n : ℤ
l' : List ℤ
ih : J(l'.prod | n✝) = (List.map (fun a => J(a | n✝)) l').prod
⊢ J((n :: l').prod | n✝) = (List.map (fun a => J(a | n✝)) (n :: l')).prod
tactic: induction' l with n l' ih
Theorem: CategoryTheory.Bicategory.LeftExtension.whiskering_map
File: Mathlib/CategoryTheory/Bicategory/Extension.lean

Proof steps:
state_before: B : Type u
inst✝ : Bicategory B
a b c : B
f : a ⟶ b
g : a ⟶ c
s t : LeftExtension f g
x : B
h : c ⟶ x
X✝ Y✝ : LeftExtension f g
η : X✝ ⟶ Y✝
⊢ ((fun t => t.whisker h) X✝).unit ≫ f ◁ η.right ▷ h = ((fun t => t.whisker h) Y✝).unit
state_after: no goals
tactic: simp [- LeftExtension.w, ← LeftExtension.w η]